// $ANTLR 3.3 Nov 30, 2010 12:50:56 cs.g 2011-02-10 04:59:06

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 219
// Unreachable code detected.
#pragma warning disable 162


using System.Collections.Generic;
using Antlr.Runtime;
using Stack = System.Collections.Generic.Stack<object>;
using List = System.Collections.IList;
using ArrayList = System.Collections.Generic.List<object>;
using Map = System.Collections.IDictionary;
using HashMap = System.Collections.Generic.Dictionary<object, object>;

using Antlr.Runtime.Tree;
using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;

[System.CodeDom.Compiler.GeneratedCode("ANTLR", "3.3 Nov 30, 2010 12:50:56")]
[System.CLSCompliant(false)]
public partial class csParser : Antlr.Runtime.Parser
{
	internal static readonly string[] tokenNames = new string[] {
		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "IDENTIFIER", "Real_literal", "NUMBER", "Hex_number", "Character_literal", "STRINGLITERAL", "Verbatim_string_literal", "TRUE", "FALSE", "NULL", "DOT", "PTR", "MINUS", "GT", "USING", "ENUM", "IF", "ELIF", "ENDIF", "DEFINE", "UNDEF", "SEMI", "RPAREN", "WS", "TS", "DOC_LINE_COMMENT", "LINE_COMMENT", "COMMENT", "EscapeSequence", "Verbatim_string_literal_character", "Decimal_digits", "INTEGER_TYPE_SUFFIX", "Decimal_integer_literal", "GooBallIdentifier", "GooBall", "IdentifierStart", "IdentifierPart", "Exponent_part", "Real_type_suffix", "Pragma", "PP_CONDITIONAL", "PREPROCESSOR_DIRECTIVE", "IF_TOKEN", "DEFINE_TOKEN", "ELSE_TOKEN", "ENDIF_TOKEN", "UNDEF_TOKEN", "PP_EXPRESSION", "PP_OR_EXPRESSION", "PP_AND_EXPRESSION", "PP_EQUALITY_EXPRESSION", "PP_UNARY_EXPRESSION", "PP_PRIMARY_EXPRESSION", "HEX_DIGIT", "HEX_DIGITS", "DECIMAL_DIGIT", "Sign", "'namespace'", "'{'", "'}'", "'extern'", "'alias'", "'='", "'partial'", "'new'", "'public'", "'protected'", "'private'", "'internal'", "'unsafe'", "'abstract'", "'sealed'", "'static'", "'readonly'", "'volatile'", "'virtual'", "'override'", "'const'", "'void'", "'this'", "'base'", "'::'", "'++'", "'--'", "'['", "']'", "'('", "','", "':'", "'out'", "'ref'", "'sizeof'", "'checked'", "'unchecked'", "'default'", "'delegate'", "'typeof'", "'<'", "'*'", "'?'", "'+'", "'!'", "'~'", "'+='", "'-='", "'*='", "'/='", "'%='", "'&='", "'|='", "'^='", "'<<='", "'>='", "'&'", "'/'", "'%'", "'<<'", "'<='", "'is'", "'as'", "'=='", "'!='", "'^'", "'|'", "'&&'", "'||'", "'??'", "'=>'", "'into'", "'from'", "'in'", "'join'", "'on'", "'equals'", "'let'", "'orderby'", "'ascending'", "'descending'", "'select'", "'group'", "'by'", "'where'", "'assembly'", "'module'", "'field'", "'event'", "'method'", "'param'", "'property'", "'return'", "'type'", "'class'", "'get'", "'set'", "'add'", "'remove'", "'sbyte'", "'byte'", "'short'", "'ushort'", "'int'", "'uint'", "'long'", "'ulong'", "'char'", "'struct'", "'__arglist'", "'params'", "'interface'", "'operator'", "'implicit'", "'explicit'", "'fixed'", "'var'", "'dynamic'", "'stackalloc'", "'else'", "'switch'", "'case'", "'while'", "'do'", "'for'", "'foreach'", "'break'", "'continue'", "'goto'", "'throw'", "'try'", "'catch'", "'finally'", "'lock'", "'yield'", "'bool'", "'decimal'", "'double'", "'float'", "'object'", "'string'", "'pragma'"
	};
	public const int EOF=-1;
	public const int T__61=61;
	public const int T__62=62;
	public const int T__63=63;
	public const int T__64=64;
	public const int T__65=65;
	public const int T__66=66;
	public const int T__67=67;
	public const int T__68=68;
	public const int T__69=69;
	public const int T__70=70;
	public const int T__71=71;
	public const int T__72=72;
	public const int T__73=73;
	public const int T__74=74;
	public const int T__75=75;
	public const int T__76=76;
	public const int T__77=77;
	public const int T__78=78;
	public const int T__79=79;
	public const int T__80=80;
	public const int T__81=81;
	public const int T__82=82;
	public const int T__83=83;
	public const int T__84=84;
	public const int T__85=85;
	public const int T__86=86;
	public const int T__87=87;
	public const int T__88=88;
	public const int T__89=89;
	public const int T__90=90;
	public const int T__91=91;
	public const int T__92=92;
	public const int T__93=93;
	public const int T__94=94;
	public const int T__95=95;
	public const int T__96=96;
	public const int T__97=97;
	public const int T__98=98;
	public const int T__99=99;
	public const int T__100=100;
	public const int T__101=101;
	public const int T__102=102;
	public const int T__103=103;
	public const int T__104=104;
	public const int T__105=105;
	public const int T__106=106;
	public const int T__107=107;
	public const int T__108=108;
	public const int T__109=109;
	public const int T__110=110;
	public const int T__111=111;
	public const int T__112=112;
	public const int T__113=113;
	public const int T__114=114;
	public const int T__115=115;
	public const int T__116=116;
	public const int T__117=117;
	public const int T__118=118;
	public const int T__119=119;
	public const int T__120=120;
	public const int T__121=121;
	public const int T__122=122;
	public const int T__123=123;
	public const int T__124=124;
	public const int T__125=125;
	public const int T__126=126;
	public const int T__127=127;
	public const int T__128=128;
	public const int T__129=129;
	public const int T__130=130;
	public const int T__131=131;
	public const int T__132=132;
	public const int T__133=133;
	public const int T__134=134;
	public const int T__135=135;
	public const int T__136=136;
	public const int T__137=137;
	public const int T__138=138;
	public const int T__139=139;
	public const int T__140=140;
	public const int T__141=141;
	public const int T__142=142;
	public const int T__143=143;
	public const int T__144=144;
	public const int T__145=145;
	public const int T__146=146;
	public const int T__147=147;
	public const int T__148=148;
	public const int T__149=149;
	public const int T__150=150;
	public const int T__151=151;
	public const int T__152=152;
	public const int T__153=153;
	public const int T__154=154;
	public const int T__155=155;
	public const int T__156=156;
	public const int T__157=157;
	public const int T__158=158;
	public const int T__159=159;
	public const int T__160=160;
	public const int T__161=161;
	public const int T__162=162;
	public const int T__163=163;
	public const int T__164=164;
	public const int T__165=165;
	public const int T__166=166;
	public const int T__167=167;
	public const int T__168=168;
	public const int T__169=169;
	public const int T__170=170;
	public const int T__171=171;
	public const int T__172=172;
	public const int T__173=173;
	public const int T__174=174;
	public const int T__175=175;
	public const int T__176=176;
	public const int T__177=177;
	public const int T__178=178;
	public const int T__179=179;
	public const int T__180=180;
	public const int T__181=181;
	public const int T__182=182;
	public const int T__183=183;
	public const int T__184=184;
	public const int T__185=185;
	public const int T__186=186;
	public const int T__187=187;
	public const int T__188=188;
	public const int T__189=189;
	public const int T__190=190;
	public const int T__191=191;
	public const int T__192=192;
	public const int T__193=193;
	public const int T__194=194;
	public const int T__195=195;
	public const int T__196=196;
	public const int T__197=197;
	public const int T__198=198;
	public const int T__199=199;
	public const int T__200=200;
	public const int T__201=201;
	public const int T__202=202;
	public const int IDENTIFIER=4;
	public const int Real_literal=5;
	public const int NUMBER=6;
	public const int Hex_number=7;
	public const int Character_literal=8;
	public const int STRINGLITERAL=9;
	public const int Verbatim_string_literal=10;
	public const int TRUE=11;
	public const int FALSE=12;
	public const int NULL=13;
	public const int DOT=14;
	public const int PTR=15;
	public const int MINUS=16;
	public const int GT=17;
	public const int USING=18;
	public const int ENUM=19;
	public const int IF=20;
	public const int ELIF=21;
	public const int ENDIF=22;
	public const int DEFINE=23;
	public const int UNDEF=24;
	public const int SEMI=25;
	public const int RPAREN=26;
	public const int WS=27;
	public const int TS=28;
	public const int DOC_LINE_COMMENT=29;
	public const int LINE_COMMENT=30;
	public const int COMMENT=31;
	public const int EscapeSequence=32;
	public const int Verbatim_string_literal_character=33;
	public const int Decimal_digits=34;
	public const int INTEGER_TYPE_SUFFIX=35;
	public const int Decimal_integer_literal=36;
	public const int GooBallIdentifier=37;
	public const int GooBall=38;
	public const int IdentifierStart=39;
	public const int IdentifierPart=40;
	public const int Exponent_part=41;
	public const int Real_type_suffix=42;
	public const int Pragma=43;
	public const int PP_CONDITIONAL=44;
	public const int PREPROCESSOR_DIRECTIVE=45;
	public const int IF_TOKEN=46;
	public const int DEFINE_TOKEN=47;
	public const int ELSE_TOKEN=48;
	public const int ENDIF_TOKEN=49;
	public const int UNDEF_TOKEN=50;
	public const int PP_EXPRESSION=51;
	public const int PP_OR_EXPRESSION=52;
	public const int PP_AND_EXPRESSION=53;
	public const int PP_EQUALITY_EXPRESSION=54;
	public const int PP_UNARY_EXPRESSION=55;
	public const int PP_PRIMARY_EXPRESSION=56;
	public const int HEX_DIGIT=57;
	public const int HEX_DIGITS=58;
	public const int DECIMAL_DIGIT=59;
	public const int Sign=60;

	// delegates
	// delegators

	#if ANTLR_DEBUG
		private static readonly bool[] decisionCanBacktrack =
			new bool[]
			{
				false, // invalid decision
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, true, 
				false, false, false, false, false, true, true, false, true, false, false, 
				false, false, false, false, false, false, true, false, false, false, 
				false, false, false, false, true, false, false, true, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, true, false, false, false, 
				false, false, false, false, false, false, false, false, true, false, 
				false, false, false, false, false, false, false, false, false, true, 
				false, true, false, true, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, true, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, true, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, true, false, false, false, false, 
				false, false, false, true, false, false, false, true, false, false, 
				false, true, false, false, false, false, true, false, false, false, 
				false, false, false, false, false, true, false, false, false, false, 
				false, false, false, false, false, false, false, true, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false, false, false, false, false, 
				false, false, false, false, false, false
			};
	#else
		private static readonly bool[] decisionCanBacktrack = new bool[0];
	#endif
	public csParser( ITokenStream input )
		: this( input, new RecognizerSharedState() )
	{
	}
	public csParser(ITokenStream input, RecognizerSharedState state)
		: base(input, state)
	{
		this.state.ruleMemo = new System.Collections.Generic.Dictionary<int, int>[356+1];

		ITreeAdaptor treeAdaptor = null;
		CreateTreeAdaptor(ref treeAdaptor);
		TreeAdaptor = treeAdaptor ?? new CommonTreeAdaptor();

		OnCreated();
	}
		
	// Implement this function in your helper file to use a custom tree adaptor
	partial void CreateTreeAdaptor(ref ITreeAdaptor adaptor);

	private ITreeAdaptor adaptor;

	public ITreeAdaptor TreeAdaptor
	{
		get
		{
			return adaptor;
		}
		set
		{
			this.adaptor = value;
		}
	}

	public override string[] TokenNames { get { return csParser.tokenNames; } }
	public override string GrammarFileName { get { return "cs.g"; } }


		protected bool is_class_modifier() 
		{
			return false;
		}


	partial void OnCreated();
	partial void EnterRule(string ruleName, int ruleIndex);
	partial void LeaveRule(string ruleName, int ruleIndex);

	#region Rules
	public class compilation_unit_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_compilation_unit();
	partial void Leave_compilation_unit();

	// $ANTLR start "compilation_unit"
	// cs.g:32:8: public compilation_unit : namespace_body[true] ;
	[GrammarRule("compilation_unit")]
	public csParser.compilation_unit_return compilation_unit()
	{
		Enter_compilation_unit();
		EnterRule("compilation_unit", 1);
		TraceIn("compilation_unit", 1);
		csParser.compilation_unit_return retval = new csParser.compilation_unit_return();
		retval.Start = (IToken)input.LT(1);
		int compilation_unit_StartIndex = input.Index;
		object root_0 = null;

		csParser.namespace_body_return namespace_body1 = default(csParser.namespace_body_return);


		try { DebugEnterRule(GrammarFileName, "compilation_unit");
		DebugLocation(32, 21);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 1)) { return retval; }
			// cs.g:32:24: ( namespace_body[true] )
			DebugEnterAlt(1);
			// cs.g:33:2: namespace_body[true]
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(33, 2);
			PushFollow(Follow._namespace_body_in_compilation_unit72);
			namespace_body1=namespace_body(true);
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_body1.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("compilation_unit", 1);
			LeaveRule("compilation_unit", 1);
			Leave_compilation_unit();
			if (state.backtracking > 0) { Memoize(input, 1, compilation_unit_StartIndex); }
		}
		DebugLocation(33, 21);
		} finally { DebugExitRule(GrammarFileName, "compilation_unit"); }
		return retval;

	}
	// $ANTLR end "compilation_unit"

	public class namespace_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_namespace_declaration();
	partial void Leave_namespace_declaration();

	// $ANTLR start "namespace_declaration"
	// cs.g:35:8: public namespace_declaration : 'namespace' qualified_identifier namespace_block ( ';' )? ;
	[GrammarRule("namespace_declaration")]
	public csParser.namespace_declaration_return namespace_declaration()
	{
		Enter_namespace_declaration();
		EnterRule("namespace_declaration", 2);
		TraceIn("namespace_declaration", 2);
		csParser.namespace_declaration_return retval = new csParser.namespace_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int namespace_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal2=null;
		IToken char_literal5=null;
		csParser.qualified_identifier_return qualified_identifier3 = default(csParser.qualified_identifier_return);
		csParser.namespace_block_return namespace_block4 = default(csParser.namespace_block_return);

		object string_literal2_tree=null;
		object char_literal5_tree=null;

		try { DebugEnterRule(GrammarFileName, "namespace_declaration");
		DebugLocation(35, 61);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 2)) { return retval; }
			// cs.g:35:29: ( 'namespace' qualified_identifier namespace_block ( ';' )? )
			DebugEnterAlt(1);
			// cs.g:36:2: 'namespace' qualified_identifier namespace_block ( ';' )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(36, 2);
			string_literal2=(IToken)Match(input,61,Follow._61_in_namespace_declaration83); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal2_tree = (object)adaptor.Create(string_literal2);
			adaptor.AddChild(root_0, string_literal2_tree);
			}
			DebugLocation(36, 16);
			PushFollow(Follow._qualified_identifier_in_namespace_declaration87);
			qualified_identifier3=qualified_identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, qualified_identifier3.Tree);
			DebugLocation(36, 39);
			PushFollow(Follow._namespace_block_in_namespace_declaration91);
			namespace_block4=namespace_block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_block4.Tree);
			DebugLocation(36, 57);
			// cs.g:36:57: ( ';' )?
			int alt1=2;
			try { DebugEnterSubRule(1);
			try { DebugEnterDecision(1, decisionCanBacktrack[1]);
			int LA1_0 = input.LA(1);

			if ((LA1_0==SEMI))
			{
				alt1=1;
			}
			} finally { DebugExitDecision(1); }
			switch (alt1)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:36:57: ';'
				{
				DebugLocation(36, 57);
				char_literal5=(IToken)Match(input,SEMI,Follow._SEMI_in_namespace_declaration95); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal5_tree = (object)adaptor.Create(char_literal5);
				adaptor.AddChild(root_0, char_literal5_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(1); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("namespace_declaration", 2);
			LeaveRule("namespace_declaration", 2);
			Leave_namespace_declaration();
			if (state.backtracking > 0) { Memoize(input, 2, namespace_declaration_StartIndex); }
		}
		DebugLocation(36, 61);
		} finally { DebugExitRule(GrammarFileName, "namespace_declaration"); }
		return retval;

	}
	// $ANTLR end "namespace_declaration"

	public class namespace_block_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_namespace_block();
	partial void Leave_namespace_block();

	// $ANTLR start "namespace_block"
	// cs.g:37:8: public namespace_block : '{' namespace_body[false] '}' ;
	[GrammarRule("namespace_block")]
	public csParser.namespace_block_return namespace_block()
	{
		Enter_namespace_block();
		EnterRule("namespace_block", 3);
		TraceIn("namespace_block", 3);
		csParser.namespace_block_return retval = new csParser.namespace_block_return();
		retval.Start = (IToken)input.LT(1);
		int namespace_block_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal6=null;
		IToken char_literal8=null;
		csParser.namespace_body_return namespace_body7 = default(csParser.namespace_body_return);

		object char_literal6_tree=null;
		object char_literal8_tree=null;

		try { DebugEnterRule(GrammarFileName, "namespace_block");
		DebugLocation(37, 35);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 3)) { return retval; }
			// cs.g:37:23: ( '{' namespace_body[false] '}' )
			DebugEnterAlt(1);
			// cs.g:38:2: '{' namespace_body[false] '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(38, 2);
			char_literal6=(IToken)Match(input,62,Follow._62_in_namespace_block106); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal6_tree = (object)adaptor.Create(char_literal6);
			adaptor.AddChild(root_0, char_literal6_tree);
			}
			DebugLocation(38, 8);
			PushFollow(Follow._namespace_body_in_namespace_block110);
			namespace_body7=namespace_body(false);
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_body7.Tree);
			DebugLocation(38, 32);
			char_literal8=(IToken)Match(input,63,Follow._63_in_namespace_block115); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal8_tree = (object)adaptor.Create(char_literal8);
			adaptor.AddChild(root_0, char_literal8_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("namespace_block", 3);
			LeaveRule("namespace_block", 3);
			Leave_namespace_block();
			if (state.backtracking > 0) { Memoize(input, 3, namespace_block_StartIndex); }
		}
		DebugLocation(38, 35);
		} finally { DebugExitRule(GrammarFileName, "namespace_block"); }
		return retval;

	}
	// $ANTLR end "namespace_block"

	public class namespace_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_namespace_body();
	partial void Leave_namespace_body();

	// $ANTLR start "namespace_body"
	// cs.g:39:1: namespace_body[bool bGlobal] : ( extern_alias_directives )? ( using_directives )? ( global_attributes )? ( namespace_member_declarations )? ;
	[GrammarRule("namespace_body")]
	private csParser.namespace_body_return namespace_body(bool bGlobal)
	{
		Enter_namespace_body();
		EnterRule("namespace_body", 4);
		TraceIn("namespace_body", 4);
		csParser.namespace_body_return retval = new csParser.namespace_body_return();
		retval.Start = (IToken)input.LT(1);
		int namespace_body_StartIndex = input.Index;
		object root_0 = null;

		csParser.extern_alias_directives_return extern_alias_directives9 = default(csParser.extern_alias_directives_return);
		csParser.using_directives_return using_directives10 = default(csParser.using_directives_return);
		csParser.global_attributes_return global_attributes11 = default(csParser.global_attributes_return);
		csParser.namespace_member_declarations_return namespace_member_declarations12 = default(csParser.namespace_member_declarations_return);


		try { DebugEnterRule(GrammarFileName, "namespace_body");
		DebugLocation(39, 100);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 4)) { return retval; }
			// cs.g:39:29: ( ( extern_alias_directives )? ( using_directives )? ( global_attributes )? ( namespace_member_declarations )? )
			DebugEnterAlt(1);
			// cs.g:40:2: ( extern_alias_directives )? ( using_directives )? ( global_attributes )? ( namespace_member_declarations )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(40, 2);
			// cs.g:40:2: ( extern_alias_directives )?
			int alt2=2;
			try { DebugEnterSubRule(2);
			try { DebugEnterDecision(2, decisionCanBacktrack[2]);
			int LA2_0 = input.LA(1);

			if ((LA2_0==64))
			{
				int LA2_1 = input.LA(2);

				if ((LA2_1==65))
				{
					alt2=1;
				}
			}
			} finally { DebugExitDecision(2); }
			switch (alt2)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:40:2: extern_alias_directives
				{
				DebugLocation(40, 2);
				PushFollow(Follow._extern_alias_directives_in_namespace_body124);
				extern_alias_directives9=extern_alias_directives();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, extern_alias_directives9.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(2); }

			DebugLocation(40, 29);
			// cs.g:40:29: ( using_directives )?
			int alt3=2;
			try { DebugEnterSubRule(3);
			try { DebugEnterDecision(3, decisionCanBacktrack[3]);
			int LA3_0 = input.LA(1);

			if ((LA3_0==USING))
			{
				alt3=1;
			}
			} finally { DebugExitDecision(3); }
			switch (alt3)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:40:29: using_directives
				{
				DebugLocation(40, 29);
				PushFollow(Follow._using_directives_in_namespace_body129);
				using_directives10=using_directives();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, using_directives10.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(3); }

			DebugLocation(40, 49);
			// cs.g:40:49: ( global_attributes )?
			int alt4=2;
			try { DebugEnterSubRule(4);
			try { DebugEnterDecision(4, decisionCanBacktrack[4]);
			int LA4_0 = input.LA(1);

			if ((LA4_0==88))
			{
				int LA4_1 = input.LA(2);

				if (((LA4_1>=146 && LA4_1<=147)))
				{
					int LA4_3 = input.LA(3);

					if ((LA4_3==92))
					{
						alt4=1;
					}
				}
			}
			} finally { DebugExitDecision(4); }
			switch (alt4)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:40:49: global_attributes
				{
				DebugLocation(40, 49);
				PushFollow(Follow._global_attributes_in_namespace_body134);
				global_attributes11=global_attributes();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, global_attributes11.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(4); }

			DebugLocation(40, 70);
			// cs.g:40:70: ( namespace_member_declarations )?
			int alt5=2;
			try { DebugEnterSubRule(5);
			try { DebugEnterDecision(5, decisionCanBacktrack[5]);
			int LA5_0 = input.LA(1);

			if ((LA5_0==ENUM||LA5_0==61||LA5_0==64||(LA5_0>=67 && LA5_0<=80)||LA5_0==88||LA5_0==99||LA5_0==155||LA5_0==169||LA5_0==172))
			{
				alt5=1;
			}
			} finally { DebugExitDecision(5); }
			switch (alt5)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:40:70: namespace_member_declarations
				{
				DebugLocation(40, 70);
				PushFollow(Follow._namespace_member_declarations_in_namespace_body139);
				namespace_member_declarations12=namespace_member_declarations();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_member_declarations12.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(5); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("namespace_body", 4);
			LeaveRule("namespace_body", 4);
			Leave_namespace_body();
			if (state.backtracking > 0) { Memoize(input, 4, namespace_body_StartIndex); }
		}
		DebugLocation(40, 100);
		} finally { DebugExitRule(GrammarFileName, "namespace_body"); }
		return retval;

	}
	// $ANTLR end "namespace_body"

	public class extern_alias_directives_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_extern_alias_directives();
	partial void Leave_extern_alias_directives();

	// $ANTLR start "extern_alias_directives"
	// cs.g:41:8: public extern_alias_directives : ( extern_alias_directive )+ ;
	[GrammarRule("extern_alias_directives")]
	public csParser.extern_alias_directives_return extern_alias_directives()
	{
		Enter_extern_alias_directives();
		EnterRule("extern_alias_directives", 5);
		TraceIn("extern_alias_directives", 5);
		csParser.extern_alias_directives_return retval = new csParser.extern_alias_directives_return();
		retval.Start = (IToken)input.LT(1);
		int extern_alias_directives_StartIndex = input.Index;
		object root_0 = null;

		csParser.extern_alias_directive_return extern_alias_directive13 = default(csParser.extern_alias_directive_return);


		try { DebugEnterRule(GrammarFileName, "extern_alias_directives");
		DebugLocation(41, 25);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 5)) { return retval; }
			// cs.g:41:31: ( ( extern_alias_directive )+ )
			DebugEnterAlt(1);
			// cs.g:42:2: ( extern_alias_directive )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(42, 2);
			// cs.g:42:2: ( extern_alias_directive )+
			int cnt6=0;
			try { DebugEnterSubRule(6);
			while (true)
			{
				int alt6=2;
				try { DebugEnterDecision(6, decisionCanBacktrack[6]);
				int LA6_0 = input.LA(1);

				if ((LA6_0==64))
				{
					int LA6_2 = input.LA(2);

					if ((LA6_2==65))
					{
						alt6=1;
					}


				}


				} finally { DebugExitDecision(6); }
				switch (alt6)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:42:2: extern_alias_directive
					{
					DebugLocation(42, 2);
					PushFollow(Follow._extern_alias_directive_in_extern_alias_directives150);
					extern_alias_directive13=extern_alias_directive();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, extern_alias_directive13.Tree);

					}
					break;

				default:
					if (cnt6 >= 1)
						goto loop6;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee6 = new EarlyExitException( 6, input );
					DebugRecognitionException(eee6);
					throw eee6;
				}
				cnt6++;
			}
			loop6:
				;

			} finally { DebugExitSubRule(6); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("extern_alias_directives", 5);
			LeaveRule("extern_alias_directives", 5);
			Leave_extern_alias_directives();
			if (state.backtracking > 0) { Memoize(input, 5, extern_alias_directives_StartIndex); }
		}
		DebugLocation(42, 25);
		} finally { DebugExitRule(GrammarFileName, "extern_alias_directives"); }
		return retval;

	}
	// $ANTLR end "extern_alias_directives"

	public class extern_alias_directive_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_extern_alias_directive();
	partial void Leave_extern_alias_directive();

	// $ANTLR start "extern_alias_directive"
	// cs.g:43:8: public extern_alias_directive : 'extern' 'alias' identifier ';' ;
	[GrammarRule("extern_alias_directive")]
	public csParser.extern_alias_directive_return extern_alias_directive()
	{
		Enter_extern_alias_directive();
		EnterRule("extern_alias_directive", 6);
		TraceIn("extern_alias_directive", 6);
		csParser.extern_alias_directive_return retval = new csParser.extern_alias_directive_return();
		retval.Start = (IToken)input.LT(1);
		int extern_alias_directive_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal14=null;
		IToken string_literal15=null;
		IToken char_literal17=null;
		csParser.identifier_return identifier16 = default(csParser.identifier_return);

		object string_literal14_tree=null;
		object string_literal15_tree=null;
		object char_literal17_tree=null;

		try { DebugEnterRule(GrammarFileName, "extern_alias_directive");
		DebugLocation(43, 38);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 6)) { return retval; }
			// cs.g:43:30: ( 'extern' 'alias' identifier ';' )
			DebugEnterAlt(1);
			// cs.g:44:2: 'extern' 'alias' identifier ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(44, 2);
			string_literal14=(IToken)Match(input,64,Follow._64_in_extern_alias_directive161); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal14_tree = (object)adaptor.Create(string_literal14);
			adaptor.AddChild(root_0, string_literal14_tree);
			}
			DebugLocation(44, 13);
			string_literal15=(IToken)Match(input,65,Follow._65_in_extern_alias_directive165); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal15_tree = (object)adaptor.Create(string_literal15);
			adaptor.AddChild(root_0, string_literal15_tree);
			}
			DebugLocation(44, 23);
			PushFollow(Follow._identifier_in_extern_alias_directive169);
			identifier16=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier16.Tree);
			DebugLocation(44, 35);
			char_literal17=(IToken)Match(input,SEMI,Follow._SEMI_in_extern_alias_directive172); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal17_tree = (object)adaptor.Create(char_literal17);
			adaptor.AddChild(root_0, char_literal17_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("extern_alias_directive", 6);
			LeaveRule("extern_alias_directive", 6);
			Leave_extern_alias_directive();
			if (state.backtracking > 0) { Memoize(input, 6, extern_alias_directive_StartIndex); }
		}
		DebugLocation(44, 38);
		} finally { DebugExitRule(GrammarFileName, "extern_alias_directive"); }
		return retval;

	}
	// $ANTLR end "extern_alias_directive"

	public class using_directives_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_using_directives();
	partial void Leave_using_directives();

	// $ANTLR start "using_directives"
	// cs.g:45:8: public using_directives : ( using_directive )+ ;
	[GrammarRule("using_directives")]
	public csParser.using_directives_return using_directives()
	{
		Enter_using_directives();
		EnterRule("using_directives", 7);
		TraceIn("using_directives", 7);
		csParser.using_directives_return retval = new csParser.using_directives_return();
		retval.Start = (IToken)input.LT(1);
		int using_directives_StartIndex = input.Index;
		object root_0 = null;

		csParser.using_directive_return using_directive18 = default(csParser.using_directive_return);


		try { DebugEnterRule(GrammarFileName, "using_directives");
		DebugLocation(45, 18);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 7)) { return retval; }
			// cs.g:45:24: ( ( using_directive )+ )
			DebugEnterAlt(1);
			// cs.g:46:2: ( using_directive )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(46, 2);
			// cs.g:46:2: ( using_directive )+
			int cnt7=0;
			try { DebugEnterSubRule(7);
			while (true)
			{
				int alt7=2;
				try { DebugEnterDecision(7, decisionCanBacktrack[7]);
				int LA7_0 = input.LA(1);

				if ((LA7_0==USING))
				{
					alt7=1;
				}


				} finally { DebugExitDecision(7); }
				switch (alt7)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:46:2: using_directive
					{
					DebugLocation(46, 2);
					PushFollow(Follow._using_directive_in_using_directives182);
					using_directive18=using_directive();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, using_directive18.Tree);

					}
					break;

				default:
					if (cnt7 >= 1)
						goto loop7;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee7 = new EarlyExitException( 7, input );
					DebugRecognitionException(eee7);
					throw eee7;
				}
				cnt7++;
			}
			loop7:
				;

			} finally { DebugExitSubRule(7); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("using_directives", 7);
			LeaveRule("using_directives", 7);
			Leave_using_directives();
			if (state.backtracking > 0) { Memoize(input, 7, using_directives_StartIndex); }
		}
		DebugLocation(46, 18);
		} finally { DebugExitRule(GrammarFileName, "using_directives"); }
		return retval;

	}
	// $ANTLR end "using_directives"

	public class using_directive_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_using_directive();
	partial void Leave_using_directive();

	// $ANTLR start "using_directive"
	// cs.g:47:8: public using_directive : ( using_alias_directive | using_namespace_directive ) ;
	[GrammarRule("using_directive")]
	public csParser.using_directive_return using_directive()
	{
		Enter_using_directive();
		EnterRule("using_directive", 8);
		TraceIn("using_directive", 8);
		csParser.using_directive_return retval = new csParser.using_directive_return();
		retval.Start = (IToken)input.LT(1);
		int using_directive_StartIndex = input.Index;
		object root_0 = null;

		csParser.using_alias_directive_return using_alias_directive19 = default(csParser.using_alias_directive_return);
		csParser.using_namespace_directive_return using_namespace_directive20 = default(csParser.using_namespace_directive_return);


		try { DebugEnterRule(GrammarFileName, "using_directive");
		DebugLocation(47, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 8)) { return retval; }
			// cs.g:47:23: ( ( using_alias_directive | using_namespace_directive ) )
			DebugEnterAlt(1);
			// cs.g:48:2: ( using_alias_directive | using_namespace_directive )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(48, 2);
			// cs.g:48:2: ( using_alias_directive | using_namespace_directive )
			int alt8=2;
			try { DebugEnterSubRule(8);
			try { DebugEnterDecision(8, decisionCanBacktrack[8]);
			int LA8_0 = input.LA(1);

			if ((LA8_0==USING))
			{
				int LA8_1 = input.LA(2);

				if ((LA8_1==IDENTIFIER))
				{
					int LA8_2 = input.LA(3);

					if ((LA8_2==66))
					{
						alt8=1;
					}
					else if ((LA8_2==DOT||LA8_2==SEMI||LA8_2==85||LA8_2==101))
					{
						alt8=2;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 8, 2, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
				}
				else if (((LA8_1>=ELIF && LA8_1<=UNDEF)||LA8_1==65||(LA8_1>=132 && LA8_1<=133)||(LA8_1>=135 && LA8_1<=148)||(LA8_1>=150 && LA8_1<=152)||LA8_1==154||(LA8_1>=156 && LA8_1<=159)||LA8_1==170||(LA8_1>=177 && LA8_1<=178)||LA8_1==195||LA8_1==202))
				{
					int LA8_3 = input.LA(3);

					if ((LA8_3==66))
					{
						alt8=1;
					}
					else if ((LA8_3==DOT||LA8_3==SEMI||LA8_3==85||LA8_3==101))
					{
						alt8=2;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 8, 3, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 8, 1, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 8, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(8); }
			switch (alt8)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:48:3: using_alias_directive
				{
				DebugLocation(48, 3);
				PushFollow(Follow._using_alias_directive_in_using_directive194);
				using_alias_directive19=using_alias_directive();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, using_alias_directive19.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:49:4: using_namespace_directive
				{
				DebugLocation(49, 4);
				PushFollow(Follow._using_namespace_directive_in_using_directive199);
				using_namespace_directive20=using_namespace_directive();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, using_namespace_directive20.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(8); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("using_directive", 8);
			LeaveRule("using_directive", 8);
			Leave_using_directive();
			if (state.backtracking > 0) { Memoize(input, 8, using_directive_StartIndex); }
		}
		DebugLocation(49, 30);
		} finally { DebugExitRule(GrammarFileName, "using_directive"); }
		return retval;

	}
	// $ANTLR end "using_directive"

	public class using_alias_directive_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_using_alias_directive();
	partial void Leave_using_alias_directive();

	// $ANTLR start "using_alias_directive"
	// cs.g:50:8: public using_alias_directive : 'using' identifier '=' namespace_or_type_name ';' ;
	[GrammarRule("using_alias_directive")]
	public csParser.using_alias_directive_return using_alias_directive()
	{
		Enter_using_alias_directive();
		EnterRule("using_alias_directive", 9);
		TraceIn("using_alias_directive", 9);
		csParser.using_alias_directive_return retval = new csParser.using_alias_directive_return();
		retval.Start = (IToken)input.LT(1);
		int using_alias_directive_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal21=null;
		IToken char_literal23=null;
		IToken char_literal25=null;
		csParser.identifier_return identifier22 = default(csParser.identifier_return);
		csParser.namespace_or_type_name_return namespace_or_type_name24 = default(csParser.namespace_or_type_name_return);

		object string_literal21_tree=null;
		object char_literal23_tree=null;
		object char_literal25_tree=null;

		try { DebugEnterRule(GrammarFileName, "using_alias_directive");
		DebugLocation(50, 59);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 9)) { return retval; }
			// cs.g:50:29: ( 'using' identifier '=' namespace_or_type_name ';' )
			DebugEnterAlt(1);
			// cs.g:51:2: 'using' identifier '=' namespace_or_type_name ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(51, 2);
			string_literal21=(IToken)Match(input,USING,Follow._USING_in_using_alias_directive210); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal21_tree = (object)adaptor.Create(string_literal21);
			adaptor.AddChild(root_0, string_literal21_tree);
			}
			DebugLocation(51, 12);
			PushFollow(Follow._identifier_in_using_alias_directive214);
			identifier22=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier22.Tree);
			DebugLocation(51, 25);
			char_literal23=(IToken)Match(input,66,Follow._66_in_using_alias_directive218); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal23_tree = (object)adaptor.Create(char_literal23);
			adaptor.AddChild(root_0, char_literal23_tree);
			}
			DebugLocation(51, 31);
			PushFollow(Follow._namespace_or_type_name_in_using_alias_directive222);
			namespace_or_type_name24=namespace_or_type_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_or_type_name24.Tree);
			DebugLocation(51, 56);
			char_literal25=(IToken)Match(input,SEMI,Follow._SEMI_in_using_alias_directive226); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal25_tree = (object)adaptor.Create(char_literal25);
			adaptor.AddChild(root_0, char_literal25_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("using_alias_directive", 9);
			LeaveRule("using_alias_directive", 9);
			Leave_using_alias_directive();
			if (state.backtracking > 0) { Memoize(input, 9, using_alias_directive_StartIndex); }
		}
		DebugLocation(51, 59);
		} finally { DebugExitRule(GrammarFileName, "using_alias_directive"); }
		return retval;

	}
	// $ANTLR end "using_alias_directive"

	public class using_namespace_directive_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_using_namespace_directive();
	partial void Leave_using_namespace_directive();

	// $ANTLR start "using_namespace_directive"
	// cs.g:52:8: public using_namespace_directive : 'using' namespace_name ';' ;
	[GrammarRule("using_namespace_directive")]
	public csParser.using_namespace_directive_return using_namespace_directive()
	{
		Enter_using_namespace_directive();
		EnterRule("using_namespace_directive", 10);
		TraceIn("using_namespace_directive", 10);
		csParser.using_namespace_directive_return retval = new csParser.using_namespace_directive_return();
		retval.Start = (IToken)input.LT(1);
		int using_namespace_directive_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal26=null;
		IToken char_literal28=null;
		csParser.namespace_name_return namespace_name27 = default(csParser.namespace_name_return);

		object string_literal26_tree=null;
		object char_literal28_tree=null;

		try { DebugEnterRule(GrammarFileName, "using_namespace_directive");
		DebugLocation(52, 32);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 10)) { return retval; }
			// cs.g:52:33: ( 'using' namespace_name ';' )
			DebugEnterAlt(1);
			// cs.g:53:2: 'using' namespace_name ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(53, 2);
			string_literal26=(IToken)Match(input,USING,Follow._USING_in_using_namespace_directive236); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal26_tree = (object)adaptor.Create(string_literal26);
			adaptor.AddChild(root_0, string_literal26_tree);
			}
			DebugLocation(53, 12);
			PushFollow(Follow._namespace_name_in_using_namespace_directive240);
			namespace_name27=namespace_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_name27.Tree);
			DebugLocation(53, 29);
			char_literal28=(IToken)Match(input,SEMI,Follow._SEMI_in_using_namespace_directive244); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal28_tree = (object)adaptor.Create(char_literal28);
			adaptor.AddChild(root_0, char_literal28_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("using_namespace_directive", 10);
			LeaveRule("using_namespace_directive", 10);
			Leave_using_namespace_directive();
			if (state.backtracking > 0) { Memoize(input, 10, using_namespace_directive_StartIndex); }
		}
		DebugLocation(53, 32);
		} finally { DebugExitRule(GrammarFileName, "using_namespace_directive"); }
		return retval;

	}
	// $ANTLR end "using_namespace_directive"

	public class namespace_member_declarations_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_namespace_member_declarations();
	partial void Leave_namespace_member_declarations();

	// $ANTLR start "namespace_member_declarations"
	// cs.g:54:8: public namespace_member_declarations : ( namespace_member_declaration )+ ;
	[GrammarRule("namespace_member_declarations")]
	public csParser.namespace_member_declarations_return namespace_member_declarations()
	{
		Enter_namespace_member_declarations();
		EnterRule("namespace_member_declarations", 11);
		TraceIn("namespace_member_declarations", 11);
		csParser.namespace_member_declarations_return retval = new csParser.namespace_member_declarations_return();
		retval.Start = (IToken)input.LT(1);
		int namespace_member_declarations_StartIndex = input.Index;
		object root_0 = null;

		csParser.namespace_member_declaration_return namespace_member_declaration29 = default(csParser.namespace_member_declaration_return);


		try { DebugEnterRule(GrammarFileName, "namespace_member_declarations");
		DebugLocation(54, 31);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 11)) { return retval; }
			// cs.g:54:37: ( ( namespace_member_declaration )+ )
			DebugEnterAlt(1);
			// cs.g:55:2: ( namespace_member_declaration )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(55, 2);
			// cs.g:55:2: ( namespace_member_declaration )+
			int cnt9=0;
			try { DebugEnterSubRule(9);
			while (true)
			{
				int alt9=2;
				try { DebugEnterDecision(9, decisionCanBacktrack[9]);
				int LA9_0 = input.LA(1);

				if ((LA9_0==ENUM||LA9_0==61||LA9_0==64||(LA9_0>=67 && LA9_0<=80)||LA9_0==88||LA9_0==99||LA9_0==155||LA9_0==169||LA9_0==172))
				{
					alt9=1;
				}


				} finally { DebugExitDecision(9); }
				switch (alt9)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:55:2: namespace_member_declaration
					{
					DebugLocation(55, 2);
					PushFollow(Follow._namespace_member_declaration_in_namespace_member_declarations254);
					namespace_member_declaration29=namespace_member_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_member_declaration29.Tree);

					}
					break;

				default:
					if (cnt9 >= 1)
						goto loop9;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee9 = new EarlyExitException( 9, input );
					DebugRecognitionException(eee9);
					throw eee9;
				}
				cnt9++;
			}
			loop9:
				;

			} finally { DebugExitSubRule(9); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("namespace_member_declarations", 11);
			LeaveRule("namespace_member_declarations", 11);
			Leave_namespace_member_declarations();
			if (state.backtracking > 0) { Memoize(input, 11, namespace_member_declarations_StartIndex); }
		}
		DebugLocation(55, 31);
		} finally { DebugExitRule(GrammarFileName, "namespace_member_declarations"); }
		return retval;

	}
	// $ANTLR end "namespace_member_declarations"

	public class namespace_member_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_namespace_member_declaration();
	partial void Leave_namespace_member_declaration();

	// $ANTLR start "namespace_member_declaration"
	// cs.g:56:8: public namespace_member_declaration : ( namespace_declaration | ( attributes )? ( modifiers )? type_declaration );
	[GrammarRule("namespace_member_declaration")]
	public csParser.namespace_member_declaration_return namespace_member_declaration()
	{
		Enter_namespace_member_declaration();
		EnterRule("namespace_member_declaration", 12);
		TraceIn("namespace_member_declaration", 12);
		csParser.namespace_member_declaration_return retval = new csParser.namespace_member_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int namespace_member_declaration_StartIndex = input.Index;
		object root_0 = null;

		csParser.namespace_declaration_return namespace_declaration30 = default(csParser.namespace_declaration_return);
		csParser.attributes_return attributes31 = default(csParser.attributes_return);
		csParser.modifiers_return modifiers32 = default(csParser.modifiers_return);
		csParser.type_declaration_return type_declaration33 = default(csParser.type_declaration_return);


		try { DebugEnterRule(GrammarFileName, "namespace_member_declaration");
		DebugLocation(56, 47);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 12)) { return retval; }
			// cs.g:56:36: ( namespace_declaration | ( attributes )? ( modifiers )? type_declaration )
			int alt12=2;
			try { DebugEnterDecision(12, decisionCanBacktrack[12]);
			int LA12_0 = input.LA(1);

			if ((LA12_0==61))
			{
				alt12=1;
			}
			else if ((LA12_0==ENUM||LA12_0==64||(LA12_0>=67 && LA12_0<=80)||LA12_0==88||LA12_0==99||LA12_0==155||LA12_0==169||LA12_0==172))
			{
				alt12=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 12, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(12); }
			switch (alt12)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:57:2: namespace_declaration
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(57, 2);
				PushFollow(Follow._namespace_declaration_in_namespace_member_declaration265);
				namespace_declaration30=namespace_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_declaration30.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:58:4: ( attributes )? ( modifiers )? type_declaration
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(58, 4);
				// cs.g:58:4: ( attributes )?
				int alt10=2;
				try { DebugEnterSubRule(10);
				try { DebugEnterDecision(10, decisionCanBacktrack[10]);
				int LA10_0 = input.LA(1);

				if ((LA10_0==88))
				{
					alt10=1;
				}
				} finally { DebugExitDecision(10); }
				switch (alt10)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:58:4: attributes
					{
					DebugLocation(58, 4);
					PushFollow(Follow._attributes_in_namespace_member_declaration270);
					attributes31=attributes();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes31.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(10); }

				DebugLocation(58, 18);
				// cs.g:58:18: ( modifiers )?
				int alt11=2;
				try { DebugEnterSubRule(11);
				try { DebugEnterDecision(11, decisionCanBacktrack[11]);
				int LA11_0 = input.LA(1);

				if ((LA11_0==64||(LA11_0>=68 && LA11_0<=80)))
				{
					alt11=1;
				}
				} finally { DebugExitDecision(11); }
				switch (alt11)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:58:18: modifiers
					{
					DebugLocation(58, 18);
					PushFollow(Follow._modifiers_in_namespace_member_declaration275);
					modifiers32=modifiers();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers32.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(11); }

				DebugLocation(58, 31);
				PushFollow(Follow._type_declaration_in_namespace_member_declaration280);
				type_declaration33=type_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_declaration33.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("namespace_member_declaration", 12);
			LeaveRule("namespace_member_declaration", 12);
			Leave_namespace_member_declaration();
			if (state.backtracking > 0) { Memoize(input, 12, namespace_member_declaration_StartIndex); }
		}
		DebugLocation(58, 47);
		} finally { DebugExitRule(GrammarFileName, "namespace_member_declaration"); }
		return retval;

	}
	// $ANTLR end "namespace_member_declaration"

	public class type_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_type_declaration();
	partial void Leave_type_declaration();

	// $ANTLR start "type_declaration"
	// cs.g:59:8: public type_declaration : ( ( 'partial' )=> 'partial' ( class_declaration | struct_declaration | interface_declaration ) | class_declaration | struct_declaration | interface_declaration | enum_declaration | delegate_declaration );
	[GrammarRule("type_declaration")]
	public csParser.type_declaration_return type_declaration()
	{
		Enter_type_declaration();
		EnterRule("type_declaration", 13);
		TraceIn("type_declaration", 13);
		csParser.type_declaration_return retval = new csParser.type_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int type_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal34=null;
		csParser.class_declaration_return class_declaration35 = default(csParser.class_declaration_return);
		csParser.struct_declaration_return struct_declaration36 = default(csParser.struct_declaration_return);
		csParser.interface_declaration_return interface_declaration37 = default(csParser.interface_declaration_return);
		csParser.class_declaration_return class_declaration38 = default(csParser.class_declaration_return);
		csParser.struct_declaration_return struct_declaration39 = default(csParser.struct_declaration_return);
		csParser.interface_declaration_return interface_declaration40 = default(csParser.interface_declaration_return);
		csParser.enum_declaration_return enum_declaration41 = default(csParser.enum_declaration_return);
		csParser.delegate_declaration_return delegate_declaration42 = default(csParser.delegate_declaration_return);

		object string_literal34_tree=null;

		try { DebugEnterRule(GrammarFileName, "type_declaration");
		DebugLocation(59, 24);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 13)) { return retval; }
			// cs.g:59:24: ( ( 'partial' )=> 'partial' ( class_declaration | struct_declaration | interface_declaration ) | class_declaration | struct_declaration | interface_declaration | enum_declaration | delegate_declaration )
			int alt14=6;
			try { DebugEnterDecision(14, decisionCanBacktrack[14]);
			int LA14_0 = input.LA(1);

			if ((LA14_0==67) && (EvaluatePredicate(synpred1_cs_fragment)))
			{
				alt14=1;
			}
			else if ((LA14_0==155))
			{
				alt14=2;
			}
			else if ((LA14_0==169))
			{
				alt14=3;
			}
			else if ((LA14_0==172))
			{
				alt14=4;
			}
			else if ((LA14_0==ENUM))
			{
				alt14=5;
			}
			else if ((LA14_0==99))
			{
				alt14=6;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 14, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(14); }
			switch (alt14)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:60:2: ( 'partial' )=> 'partial' ( class_declaration | struct_declaration | interface_declaration )
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(60, 17);
				string_literal34=(IToken)Match(input,67,Follow._67_in_type_declaration296); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal34_tree = (object)adaptor.Create(string_literal34);
				adaptor.AddChild(root_0, string_literal34_tree);
				}
				DebugLocation(60, 29);
				// cs.g:60:29: ( class_declaration | struct_declaration | interface_declaration )
				int alt13=3;
				try { DebugEnterSubRule(13);
				try { DebugEnterDecision(13, decisionCanBacktrack[13]);
				switch (input.LA(1))
				{
				case 155:
					{
					alt13=1;
					}
					break;
				case 169:
					{
					alt13=2;
					}
					break;
				case 172:
					{
					alt13=3;
					}
					break;
				default:
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 13, 0, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
				}

				} finally { DebugExitDecision(13); }
				switch (alt13)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:60:30: class_declaration
					{
					DebugLocation(60, 30);
					PushFollow(Follow._class_declaration_in_type_declaration301);
					class_declaration35=class_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration35.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:61:11: struct_declaration
					{
					DebugLocation(61, 11);
					PushFollow(Follow._struct_declaration_in_type_declaration313);
					struct_declaration36=struct_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration36.Tree);

					}
					break;
				case 3:
					DebugEnterAlt(3);
					// cs.g:62:11: interface_declaration
					{
					DebugLocation(62, 11);
					PushFollow(Follow._interface_declaration_in_type_declaration325);
					interface_declaration37=interface_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration37.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(13); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:63:4: class_declaration
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(63, 4);
				PushFollow(Follow._class_declaration_in_type_declaration331);
				class_declaration38=class_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration38.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:64:4: struct_declaration
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(64, 4);
				PushFollow(Follow._struct_declaration_in_type_declaration336);
				struct_declaration39=struct_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration39.Tree);

				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:65:4: interface_declaration
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(65, 4);
				PushFollow(Follow._interface_declaration_in_type_declaration341);
				interface_declaration40=interface_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration40.Tree);

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:66:4: enum_declaration
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(66, 4);
				PushFollow(Follow._enum_declaration_in_type_declaration346);
				enum_declaration41=enum_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_declaration41.Tree);

				}
				break;
			case 6:
				DebugEnterAlt(6);
				// cs.g:67:4: delegate_declaration
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(67, 4);
				PushFollow(Follow._delegate_declaration_in_type_declaration351);
				delegate_declaration42=delegate_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, delegate_declaration42.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("type_declaration", 13);
			LeaveRule("type_declaration", 13);
			Leave_type_declaration();
			if (state.backtracking > 0) { Memoize(input, 13, type_declaration_StartIndex); }
		}
		DebugLocation(67, 24);
		} finally { DebugExitRule(GrammarFileName, "type_declaration"); }
		return retval;

	}
	// $ANTLR end "type_declaration"

	public class qualified_identifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_qualified_identifier();
	partial void Leave_qualified_identifier();

	// $ANTLR start "qualified_identifier"
	// cs.g:69:8: public qualified_identifier : identifier ( '.' identifier )* ;
	[GrammarRule("qualified_identifier")]
	public csParser.qualified_identifier_return qualified_identifier()
	{
		Enter_qualified_identifier();
		EnterRule("qualified_identifier", 14);
		TraceIn("qualified_identifier", 14);
		csParser.qualified_identifier_return retval = new csParser.qualified_identifier_return();
		retval.Start = (IToken)input.LT(1);
		int qualified_identifier_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal44=null;
		csParser.identifier_return identifier43 = default(csParser.identifier_return);
		csParser.identifier_return identifier45 = default(csParser.identifier_return);

		object char_literal44_tree=null;

		try { DebugEnterRule(GrammarFileName, "qualified_identifier");
		DebugLocation(69, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 14)) { return retval; }
			// cs.g:69:28: ( identifier ( '.' identifier )* )
			DebugEnterAlt(1);
			// cs.g:70:2: identifier ( '.' identifier )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(70, 2);
			PushFollow(Follow._identifier_in_qualified_identifier362);
			identifier43=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier43.Tree);
			DebugLocation(70, 13);
			// cs.g:70:13: ( '.' identifier )*
			try { DebugEnterSubRule(15);
			while (true)
			{
				int alt15=2;
				try { DebugEnterDecision(15, decisionCanBacktrack[15]);
				int LA15_0 = input.LA(1);

				if ((LA15_0==DOT))
				{
					alt15=1;
				}


				} finally { DebugExitDecision(15); }
				switch ( alt15 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:70:14: '.' identifier
					{
					DebugLocation(70, 14);
					char_literal44=(IToken)Match(input,DOT,Follow._DOT_in_qualified_identifier365); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal44_tree = (object)adaptor.Create(char_literal44);
					adaptor.AddChild(root_0, char_literal44_tree);
					}
					DebugLocation(70, 18);
					PushFollow(Follow._identifier_in_qualified_identifier367);
					identifier45=identifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier45.Tree);

					}
					break;

				default:
					goto loop15;
				}
			}

			loop15:
				;

			} finally { DebugExitSubRule(15); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("qualified_identifier", 14);
			LeaveRule("qualified_identifier", 14);
			Leave_qualified_identifier();
			if (state.backtracking > 0) { Memoize(input, 14, qualified_identifier_StartIndex); }
		}
		DebugLocation(70, 30);
		} finally { DebugExitRule(GrammarFileName, "qualified_identifier"); }
		return retval;

	}
	// $ANTLR end "qualified_identifier"

	public class namespace_name_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_namespace_name();
	partial void Leave_namespace_name();

	// $ANTLR start "namespace_name"
	// cs.g:71:1: namespace_name : namespace_or_type_name ;
	[GrammarRule("namespace_name")]
	private csParser.namespace_name_return namespace_name()
	{
		Enter_namespace_name();
		EnterRule("namespace_name", 15);
		TraceIn("namespace_name", 15);
		csParser.namespace_name_return retval = new csParser.namespace_name_return();
		retval.Start = (IToken)input.LT(1);
		int namespace_name_StartIndex = input.Index;
		object root_0 = null;

		csParser.namespace_or_type_name_return namespace_or_type_name46 = default(csParser.namespace_or_type_name_return);


		try { DebugEnterRule(GrammarFileName, "namespace_name");
		DebugLocation(71, 26);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 15)) { return retval; }
			// cs.g:72:2: ( namespace_or_type_name )
			DebugEnterAlt(1);
			// cs.g:72:4: namespace_or_type_name
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(72, 4);
			PushFollow(Follow._namespace_or_type_name_in_namespace_name378);
			namespace_or_type_name46=namespace_or_type_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_or_type_name46.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("namespace_name", 15);
			LeaveRule("namespace_name", 15);
			Leave_namespace_name();
			if (state.backtracking > 0) { Memoize(input, 15, namespace_name_StartIndex); }
		}
		DebugLocation(72, 26);
		} finally { DebugExitRule(GrammarFileName, "namespace_name"); }
		return retval;

	}
	// $ANTLR end "namespace_name"

	public class modifiers_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_modifiers();
	partial void Leave_modifiers();

	// $ANTLR start "modifiers"
	// cs.g:74:8: public modifiers : ( modifier )+ ;
	[GrammarRule("modifiers")]
	public csParser.modifiers_return modifiers()
	{
		Enter_modifiers();
		EnterRule("modifiers", 16);
		TraceIn("modifiers", 16);
		csParser.modifiers_return retval = new csParser.modifiers_return();
		retval.Start = (IToken)input.LT(1);
		int modifiers_StartIndex = input.Index;
		object root_0 = null;

		csParser.modifier_return modifier47 = default(csParser.modifier_return);


		try { DebugEnterRule(GrammarFileName, "modifiers");
		DebugLocation(74, 11);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 16)) { return retval; }
			// cs.g:74:17: ( ( modifier )+ )
			DebugEnterAlt(1);
			// cs.g:75:2: ( modifier )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(75, 2);
			// cs.g:75:2: ( modifier )+
			int cnt16=0;
			try { DebugEnterSubRule(16);
			while (true)
			{
				int alt16=2;
				try { DebugEnterDecision(16, decisionCanBacktrack[16]);
				int LA16_0 = input.LA(1);

				if ((LA16_0==64||(LA16_0>=68 && LA16_0<=80)))
				{
					alt16=1;
				}


				} finally { DebugExitDecision(16); }
				switch (alt16)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:75:2: modifier
					{
					DebugLocation(75, 2);
					PushFollow(Follow._modifier_in_modifiers389);
					modifier47=modifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifier47.Tree);

					}
					break;

				default:
					if (cnt16 >= 1)
						goto loop16;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee16 = new EarlyExitException( 16, input );
					DebugRecognitionException(eee16);
					throw eee16;
				}
				cnt16++;
			}
			loop16:
				;

			} finally { DebugExitSubRule(16); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("modifiers", 16);
			LeaveRule("modifiers", 16);
			Leave_modifiers();
			if (state.backtracking > 0) { Memoize(input, 16, modifiers_StartIndex); }
		}
		DebugLocation(75, 11);
		} finally { DebugExitRule(GrammarFileName, "modifiers"); }
		return retval;

	}
	// $ANTLR end "modifiers"

	public class modifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_modifier();
	partial void Leave_modifier();

	// $ANTLR start "modifier"
	// cs.g:76:8: public modifier : ( 'new' | 'public' | 'protected' | 'private' | 'internal' | 'unsafe' | 'abstract' | 'sealed' | 'static' | 'readonly' | 'volatile' | 'extern' | 'virtual' | 'override' );
	[GrammarRule("modifier")]
	public csParser.modifier_return modifier()
	{
		Enter_modifier();
		EnterRule("modifier", 17);
		TraceIn("modifier", 17);
		csParser.modifier_return retval = new csParser.modifier_return();
		retval.Start = (IToken)input.LT(1);
		int modifier_StartIndex = input.Index;
		object root_0 = null;

		IToken set48=null;

		object set48_tree=null;

		try { DebugEnterRule(GrammarFileName, "modifier");
		DebugLocation(76, 62);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 17)) { return retval; }
			// cs.g:76:16: ( 'new' | 'public' | 'protected' | 'private' | 'internal' | 'unsafe' | 'abstract' | 'sealed' | 'static' | 'readonly' | 'volatile' | 'extern' | 'virtual' | 'override' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(76, 16);
			set48=(IToken)input.LT(1);
			if (input.LA(1)==64||(input.LA(1)>=68 && input.LA(1)<=80))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set48));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("modifier", 17);
			LeaveRule("modifier", 17);
			Leave_modifier();
			if (state.backtracking > 0) { Memoize(input, 17, modifier_StartIndex); }
		}
		DebugLocation(78, 62);
		} finally { DebugExitRule(GrammarFileName, "modifier"); }
		return retval;

	}
	// $ANTLR end "modifier"

	public class class_member_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_class_member_declaration();
	partial void Leave_class_member_declaration();

	// $ANTLR start "class_member_declaration"
	// cs.g:80:8: public class_member_declaration : ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( 'void' method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | class_declaration | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration | destructor_declaration ) ;
	[GrammarRule("class_member_declaration")]
	public csParser.class_member_declaration_return class_member_declaration()
	{
		Enter_class_member_declaration();
		EnterRule("class_member_declaration", 18);
		TraceIn("class_member_declaration", 18);
		csParser.class_member_declaration_return retval = new csParser.class_member_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int class_member_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal50=null;
		IToken char_literal53=null;
		IToken string_literal55=null;
		IToken string_literal56=null;
		IToken string_literal62=null;
		IToken char_literal68=null;
		csParser.modifiers_return m = default(csParser.modifiers_return);
		csParser.attributes_return attributes49 = default(csParser.attributes_return);
		csParser.type_return type51 = default(csParser.type_return);
		csParser.constant_declarators_return constant_declarators52 = default(csParser.constant_declarators_return);
		csParser.event_declaration_return event_declaration54 = default(csParser.event_declaration_return);
		csParser.method_declaration_return method_declaration57 = default(csParser.method_declaration_return);
		csParser.interface_declaration_return interface_declaration58 = default(csParser.interface_declaration_return);
		csParser.class_declaration_return class_declaration59 = default(csParser.class_declaration_return);
		csParser.struct_declaration_return struct_declaration60 = default(csParser.struct_declaration_return);
		csParser.interface_declaration_return interface_declaration61 = default(csParser.interface_declaration_return);
		csParser.method_declaration_return method_declaration63 = default(csParser.method_declaration_return);
		csParser.type_return type64 = default(csParser.type_return);
		csParser.method_declaration_return method_declaration65 = default(csParser.method_declaration_return);
		csParser.property_declaration_return property_declaration66 = default(csParser.property_declaration_return);
		csParser.type_name_return type_name67 = default(csParser.type_name_return);
		csParser.indexer_declaration_return indexer_declaration69 = default(csParser.indexer_declaration_return);
		csParser.indexer_declaration_return indexer_declaration70 = default(csParser.indexer_declaration_return);
		csParser.field_declaration_return field_declaration71 = default(csParser.field_declaration_return);
		csParser.operator_declaration_return operator_declaration72 = default(csParser.operator_declaration_return);
		csParser.class_declaration_return class_declaration73 = default(csParser.class_declaration_return);
		csParser.struct_declaration_return struct_declaration74 = default(csParser.struct_declaration_return);
		csParser.enum_declaration_return enum_declaration75 = default(csParser.enum_declaration_return);
		csParser.delegate_declaration_return delegate_declaration76 = default(csParser.delegate_declaration_return);
		csParser.conversion_operator_declaration_return conversion_operator_declaration77 = default(csParser.conversion_operator_declaration_return);
		csParser.constructor_declaration_return constructor_declaration78 = default(csParser.constructor_declaration_return);
		csParser.destructor_declaration_return destructor_declaration79 = default(csParser.destructor_declaration_return);

		object string_literal50_tree=null;
		object char_literal53_tree=null;
		object string_literal55_tree=null;
		object string_literal56_tree=null;
		object string_literal62_tree=null;
		object char_literal68_tree=null;

		try { DebugEnterRule(GrammarFileName, "class_member_declaration");
		DebugLocation(80, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 18)) { return retval; }
			// cs.g:80:32: ( ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( 'void' method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | class_declaration | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration | destructor_declaration ) )
			DebugEnterAlt(1);
			// cs.g:81:2: ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( 'void' method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | class_declaration | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration | destructor_declaration )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(81, 2);
			// cs.g:81:2: ( attributes )?
			int alt17=2;
			try { DebugEnterSubRule(17);
			try { DebugEnterDecision(17, decisionCanBacktrack[17]);
			int LA17_0 = input.LA(1);

			if ((LA17_0==88))
			{
				alt17=1;
			}
			} finally { DebugExitDecision(17); }
			switch (alt17)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:81:2: attributes
				{
				DebugLocation(81, 2);
				PushFollow(Follow._attributes_in_class_member_declaration465);
				attributes49=attributes();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes49.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(17); }

			DebugLocation(82, 3);
			// cs.g:82:3: (m= modifiers )?
			int alt18=2;
			try { DebugEnterSubRule(18);
			try { DebugEnterDecision(18, decisionCanBacktrack[18]);
			int LA18_0 = input.LA(1);

			if ((LA18_0==64||(LA18_0>=68 && LA18_0<=80)))
			{
				alt18=1;
			}
			} finally { DebugExitDecision(18); }
			switch (alt18)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:82:3: m= modifiers
				{
				DebugLocation(82, 3);
				PushFollow(Follow._modifiers_in_class_member_declaration471);
				m=modifiers();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, m.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(18); }

			DebugLocation(83, 2);
			// cs.g:83:2: ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( 'void' method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | class_declaration | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration | destructor_declaration )
			int alt21=13;
			try { DebugEnterSubRule(21);
			try { DebugEnterDecision(21, decisionCanBacktrack[21]);
			try
			{
				alt21 = dfa21.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(21); }
			switch (alt21)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:83:4: 'const' type constant_declarators ';'
				{
				DebugLocation(83, 4);
				string_literal50=(IToken)Match(input,81,Follow._81_in_class_member_declaration477); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal50_tree = (object)adaptor.Create(string_literal50);
				adaptor.AddChild(root_0, string_literal50_tree);
				}
				DebugLocation(83, 14);
				PushFollow(Follow._type_in_class_member_declaration481);
				type51=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type51.Tree);
				DebugLocation(83, 21);
				PushFollow(Follow._constant_declarators_in_class_member_declaration485);
				constant_declarators52=constant_declarators();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarators52.Tree);
				DebugLocation(83, 44);
				char_literal53=(IToken)Match(input,SEMI,Follow._SEMI_in_class_member_declaration489); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal53_tree = (object)adaptor.Create(char_literal53);
				adaptor.AddChild(root_0, char_literal53_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:84:4: event_declaration
				{
				DebugLocation(84, 4);
				PushFollow(Follow._event_declaration_in_class_member_declaration494);
				event_declaration54=event_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, event_declaration54.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:85:4: 'partial' ( 'void' method_declaration | interface_declaration | class_declaration | struct_declaration )
				{
				DebugLocation(85, 4);
				string_literal55=(IToken)Match(input,67,Follow._67_in_class_member_declaration501); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal55_tree = (object)adaptor.Create(string_literal55);
				adaptor.AddChild(root_0, string_literal55_tree);
				}
				DebugLocation(85, 14);
				// cs.g:85:14: ( 'void' method_declaration | interface_declaration | class_declaration | struct_declaration )
				int alt19=4;
				try { DebugEnterSubRule(19);
				try { DebugEnterDecision(19, decisionCanBacktrack[19]);
				switch (input.LA(1))
				{
				case 82:
					{
					alt19=1;
					}
					break;
				case 172:
					{
					alt19=2;
					}
					break;
				case 155:
					{
					alt19=3;
					}
					break;
				case 169:
					{
					alt19=4;
					}
					break;
				default:
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 19, 0, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
				}

				} finally { DebugExitDecision(19); }
				switch (alt19)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:85:15: 'void' method_declaration
					{
					DebugLocation(85, 15);
					string_literal56=(IToken)Match(input,82,Follow._82_in_class_member_declaration504); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					string_literal56_tree = (object)adaptor.Create(string_literal56);
					adaptor.AddChild(root_0, string_literal56_tree);
					}
					DebugLocation(85, 22);
					PushFollow(Follow._method_declaration_in_class_member_declaration506);
					method_declaration57=method_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration57.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:86:9: interface_declaration
					{
					DebugLocation(86, 9);
					PushFollow(Follow._interface_declaration_in_class_member_declaration517);
					interface_declaration58=interface_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration58.Tree);

					}
					break;
				case 3:
					DebugEnterAlt(3);
					// cs.g:87:9: class_declaration
					{
					DebugLocation(87, 9);
					PushFollow(Follow._class_declaration_in_class_member_declaration528);
					class_declaration59=class_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration59.Tree);

					}
					break;
				case 4:
					DebugEnterAlt(4);
					// cs.g:88:9: struct_declaration
					{
					DebugLocation(88, 9);
					PushFollow(Follow._struct_declaration_in_class_member_declaration539);
					struct_declaration60=struct_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration60.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(19); }


				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:89:4: interface_declaration
				{
				DebugLocation(89, 4);
				PushFollow(Follow._interface_declaration_in_class_member_declaration545);
				interface_declaration61=interface_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration61.Tree);

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:90:4: 'void' method_declaration
				{
				DebugLocation(90, 4);
				string_literal62=(IToken)Match(input,82,Follow._82_in_class_member_declaration551); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal62_tree = (object)adaptor.Create(string_literal62);
				adaptor.AddChild(root_0, string_literal62_tree);
				}
				DebugLocation(90, 13);
				PushFollow(Follow._method_declaration_in_class_member_declaration555);
				method_declaration63=method_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration63.Tree);

				}
				break;
			case 6:
				DebugEnterAlt(6);
				// cs.g:91:4: type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )
				{
				DebugLocation(91, 4);
				PushFollow(Follow._type_in_class_member_declaration560);
				type64=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type64.Tree);
				DebugLocation(91, 9);
				// cs.g:91:9: ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )
				int alt20=6;
				try { DebugEnterSubRule(20);
				try { DebugEnterDecision(20, decisionCanBacktrack[20]);
				try
				{
					alt20 = dfa20.Predict(input);
				}
				catch (NoViableAltException nvae)
				{
					DebugRecognitionException(nvae);
					throw;
				}
				} finally { DebugExitDecision(20); }
				switch (alt20)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:91:11: ( member_name '(' )=> method_declaration
					{
					DebugLocation(91, 34);
					PushFollow(Follow._method_declaration_in_class_member_declaration574);
					method_declaration65=method_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration65.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:92:8: ( member_name '{' )=> property_declaration
					{
					DebugLocation(92, 31);
					PushFollow(Follow._property_declaration_in_class_member_declaration593);
					property_declaration66=property_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, property_declaration66.Tree);

					}
					break;
				case 3:
					DebugEnterAlt(3);
					// cs.g:93:8: ( member_name '.' 'this' )=> type_name '.' indexer_declaration
					{
					DebugLocation(93, 40);
					PushFollow(Follow._type_name_in_class_member_declaration616);
					type_name67=type_name();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name67.Tree);
					DebugLocation(93, 50);
					char_literal68=(IToken)Match(input,DOT,Follow._DOT_in_class_member_declaration618); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal68_tree = (object)adaptor.Create(char_literal68);
					adaptor.AddChild(root_0, char_literal68_tree);
					}
					DebugLocation(93, 54);
					PushFollow(Follow._indexer_declaration_in_class_member_declaration620);
					indexer_declaration69=indexer_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, indexer_declaration69.Tree);

					}
					break;
				case 4:
					DebugEnterAlt(4);
					// cs.g:94:8: indexer_declaration
					{
					DebugLocation(94, 8);
					PushFollow(Follow._indexer_declaration_in_class_member_declaration629);
					indexer_declaration70=indexer_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, indexer_declaration70.Tree);

					}
					break;
				case 5:
					DebugEnterAlt(5);
					// cs.g:95:11: field_declaration
					{
					DebugLocation(95, 11);
					PushFollow(Follow._field_declaration_in_class_member_declaration642);
					field_declaration71=field_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, field_declaration71.Tree);

					}
					break;
				case 6:
					DebugEnterAlt(6);
					// cs.g:96:11: operator_declaration
					{
					DebugLocation(96, 11);
					PushFollow(Follow._operator_declaration_in_class_member_declaration660);
					operator_declaration72=operator_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, operator_declaration72.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(20); }


				}
				break;
			case 7:
				DebugEnterAlt(7);
				// cs.g:100:4: class_declaration
				{
				DebugLocation(100, 4);
				PushFollow(Follow._class_declaration_in_class_member_declaration678);
				class_declaration73=class_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration73.Tree);

				}
				break;
			case 8:
				DebugEnterAlt(8);
				// cs.g:101:4: struct_declaration
				{
				DebugLocation(101, 4);
				PushFollow(Follow._struct_declaration_in_class_member_declaration685);
				struct_declaration74=struct_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration74.Tree);

				}
				break;
			case 9:
				DebugEnterAlt(9);
				// cs.g:102:4: enum_declaration
				{
				DebugLocation(102, 4);
				PushFollow(Follow._enum_declaration_in_class_member_declaration691);
				enum_declaration75=enum_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_declaration75.Tree);

				}
				break;
			case 10:
				DebugEnterAlt(10);
				// cs.g:103:4: delegate_declaration
				{
				DebugLocation(103, 4);
				PushFollow(Follow._delegate_declaration_in_class_member_declaration698);
				delegate_declaration76=delegate_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, delegate_declaration76.Tree);

				}
				break;
			case 11:
				DebugEnterAlt(11);
				// cs.g:104:4: conversion_operator_declaration
				{
				DebugLocation(104, 4);
				PushFollow(Follow._conversion_operator_declaration_in_class_member_declaration704);
				conversion_operator_declaration77=conversion_operator_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conversion_operator_declaration77.Tree);

				}
				break;
			case 12:
				DebugEnterAlt(12);
				// cs.g:105:4: constructor_declaration
				{
				DebugLocation(105, 4);
				PushFollow(Follow._constructor_declaration_in_class_member_declaration709);
				constructor_declaration78=constructor_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_declaration78.Tree);

				}
				break;
			case 13:
				DebugEnterAlt(13);
				// cs.g:106:4: destructor_declaration
				{
				DebugLocation(106, 4);
				PushFollow(Follow._destructor_declaration_in_class_member_declaration715);
				destructor_declaration79=destructor_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, destructor_declaration79.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(21); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("class_member_declaration", 18);
			LeaveRule("class_member_declaration", 18);
			Leave_class_member_declaration();
			if (state.backtracking > 0) { Memoize(input, 18, class_member_declaration_StartIndex); }
		}
		DebugLocation(108, 1);
		} finally { DebugExitRule(GrammarFileName, "class_member_declaration"); }
		return retval;

	}
	// $ANTLR end "class_member_declaration"

	public class primary_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_primary_expression();
	partial void Leave_primary_expression();

	// $ANTLR start "primary_expression"
	// cs.g:110:8: public primary_expression : ( ( 'this' brackets )=> 'this' brackets ( primary_expression_part )* | ( 'base' brackets )=> 'base' brackets ( primary_expression_part )* | primary_expression_start ( primary_expression_part )* | 'new' ( ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+ | ( delegate_creation_expression )=> delegate_creation_expression | object_creation_expression | anonymous_object_creation_expression ) | sizeof_expression | checked_expression | unchecked_expression | default_value_expression | anonymous_method_expression );
	[GrammarRule("primary_expression")]
	public csParser.primary_expression_return primary_expression()
	{
		Enter_primary_expression();
		EnterRule("primary_expression", 19);
		TraceIn("primary_expression", 19);
		csParser.primary_expression_return retval = new csParser.primary_expression_return();
		retval.Start = (IToken)input.LT(1);
		int primary_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal80=null;
		IToken string_literal83=null;
		IToken string_literal88=null;
		csParser.brackets_return brackets81 = default(csParser.brackets_return);
		csParser.primary_expression_part_return primary_expression_part82 = default(csParser.primary_expression_part_return);
		csParser.brackets_return brackets84 = default(csParser.brackets_return);
		csParser.primary_expression_part_return primary_expression_part85 = default(csParser.primary_expression_part_return);
		csParser.primary_expression_start_return primary_expression_start86 = default(csParser.primary_expression_start_return);
		csParser.primary_expression_part_return primary_expression_part87 = default(csParser.primary_expression_part_return);
		csParser.object_creation_expression_return object_creation_expression89 = default(csParser.object_creation_expression_return);
		csParser.primary_expression_part_return primary_expression_part90 = default(csParser.primary_expression_part_return);
		csParser.delegate_creation_expression_return delegate_creation_expression91 = default(csParser.delegate_creation_expression_return);
		csParser.object_creation_expression_return object_creation_expression92 = default(csParser.object_creation_expression_return);
		csParser.anonymous_object_creation_expression_return anonymous_object_creation_expression93 = default(csParser.anonymous_object_creation_expression_return);
		csParser.sizeof_expression_return sizeof_expression94 = default(csParser.sizeof_expression_return);
		csParser.checked_expression_return checked_expression95 = default(csParser.checked_expression_return);
		csParser.unchecked_expression_return unchecked_expression96 = default(csParser.unchecked_expression_return);
		csParser.default_value_expression_return default_value_expression97 = default(csParser.default_value_expression_return);
		csParser.anonymous_method_expression_return anonymous_method_expression98 = default(csParser.anonymous_method_expression_return);

		object string_literal80_tree=null;
		object string_literal83_tree=null;
		object string_literal88_tree=null;

		try { DebugEnterRule(GrammarFileName, "primary_expression");
		DebugLocation(110, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 19)) { return retval; }
			// cs.g:110:26: ( ( 'this' brackets )=> 'this' brackets ( primary_expression_part )* | ( 'base' brackets )=> 'base' brackets ( primary_expression_part )* | primary_expression_start ( primary_expression_part )* | 'new' ( ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+ | ( delegate_creation_expression )=> delegate_creation_expression | object_creation_expression | anonymous_object_creation_expression ) | sizeof_expression | checked_expression | unchecked_expression | default_value_expression | anonymous_method_expression )
			int alt27=9;
			try { DebugEnterDecision(27, decisionCanBacktrack[27]);
			try
			{
				alt27 = dfa27.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(27); }
			switch (alt27)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:111:2: ( 'this' brackets )=> 'this' brackets ( primary_expression_part )*
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(111, 26);
				string_literal80=(IToken)Match(input,83,Follow._83_in_primary_expression743); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal80_tree = (object)adaptor.Create(string_literal80);
				adaptor.AddChild(root_0, string_literal80_tree);
				}
				DebugLocation(111, 35);
				PushFollow(Follow._brackets_in_primary_expression747);
				brackets81=brackets();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, brackets81.Tree);
				DebugLocation(111, 46);
				// cs.g:111:46: ( primary_expression_part )*
				try { DebugEnterSubRule(22);
				while (true)
				{
					int alt22=2;
					try { DebugEnterDecision(22, decisionCanBacktrack[22]);
					int LA22_0 = input.LA(1);

					if (((LA22_0>=DOT && LA22_0<=PTR)||(LA22_0>=86 && LA22_0<=88)||LA22_0==90))
					{
						alt22=1;
					}


					} finally { DebugExitDecision(22); }
					switch ( alt22 )
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:111:46: primary_expression_part
						{
						DebugLocation(111, 46);
						PushFollow(Follow._primary_expression_part_in_primary_expression751);
						primary_expression_part82=primary_expression_part();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression_part82.Tree);

						}
						break;

					default:
						goto loop22;
					}
				}

				loop22:
					;

				} finally { DebugExitSubRule(22); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:112:4: ( 'base' brackets )=> 'base' brackets ( primary_expression_part )*
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(112, 27);
				string_literal83=(IToken)Match(input,84,Follow._84_in_primary_expression767); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal83_tree = (object)adaptor.Create(string_literal83);
				adaptor.AddChild(root_0, string_literal83_tree);
				}
				DebugLocation(112, 36);
				PushFollow(Follow._brackets_in_primary_expression771);
				brackets84=brackets();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, brackets84.Tree);
				DebugLocation(112, 47);
				// cs.g:112:47: ( primary_expression_part )*
				try { DebugEnterSubRule(23);
				while (true)
				{
					int alt23=2;
					try { DebugEnterDecision(23, decisionCanBacktrack[23]);
					int LA23_0 = input.LA(1);

					if (((LA23_0>=DOT && LA23_0<=PTR)||(LA23_0>=86 && LA23_0<=88)||LA23_0==90))
					{
						alt23=1;
					}


					} finally { DebugExitDecision(23); }
					switch ( alt23 )
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:112:47: primary_expression_part
						{
						DebugLocation(112, 47);
						PushFollow(Follow._primary_expression_part_in_primary_expression775);
						primary_expression_part85=primary_expression_part();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression_part85.Tree);

						}
						break;

					default:
						goto loop23;
					}
				}

				loop23:
					;

				} finally { DebugExitSubRule(23); }


				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:113:4: primary_expression_start ( primary_expression_part )*
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(113, 4);
				PushFollow(Follow._primary_expression_start_in_primary_expression781);
				primary_expression_start86=primary_expression_start();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression_start86.Tree);
				DebugLocation(113, 31);
				// cs.g:113:31: ( primary_expression_part )*
				try { DebugEnterSubRule(24);
				while (true)
				{
					int alt24=2;
					try { DebugEnterDecision(24, decisionCanBacktrack[24]);
					int LA24_0 = input.LA(1);

					if (((LA24_0>=DOT && LA24_0<=PTR)||(LA24_0>=86 && LA24_0<=88)||LA24_0==90))
					{
						alt24=1;
					}


					} finally { DebugExitDecision(24); }
					switch ( alt24 )
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:113:31: primary_expression_part
						{
						DebugLocation(113, 31);
						PushFollow(Follow._primary_expression_part_in_primary_expression785);
						primary_expression_part87=primary_expression_part();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression_part87.Tree);

						}
						break;

					default:
						goto loop24;
					}
				}

				loop24:
					;

				} finally { DebugExitSubRule(24); }


				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:114:4: 'new' ( ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+ | ( delegate_creation_expression )=> delegate_creation_expression | object_creation_expression | anonymous_object_creation_expression )
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(114, 4);
				string_literal88=(IToken)Match(input,68,Follow._68_in_primary_expression791); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal88_tree = (object)adaptor.Create(string_literal88);
				adaptor.AddChild(root_0, string_literal88_tree);
				}
				DebugLocation(114, 10);
				// cs.g:114:10: ( ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+ | ( delegate_creation_expression )=> delegate_creation_expression | object_creation_expression | anonymous_object_creation_expression )
				int alt26=4;
				try { DebugEnterSubRule(26);
				try { DebugEnterDecision(26, decisionCanBacktrack[26]);
				switch (input.LA(1))
				{
				case 160:
				case 161:
				case 162:
				case 163:
				case 164:
				case 165:
				case 166:
				case 167:
				case 168:
				case 196:
				case 197:
				case 198:
				case 199:
				case 200:
				case 201:
					{
					int LA26_1 = input.LA(2);

					if ((EvaluatePredicate(synpred7_cs_fragment)))
					{
						alt26=1;
					}
					else if ((true))
					{
						alt26=3;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 26, 1, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
					}
					break;
				case IDENTIFIER:
					{
					int LA26_2 = input.LA(2);

					if ((EvaluatePredicate(synpred7_cs_fragment)))
					{
						alt26=1;
					}
					else if ((EvaluatePredicate(synpred8_cs_fragment)))
					{
						alt26=2;
					}
					else if ((true))
					{
						alt26=3;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 26, 2, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
					}
					break;
				case ELIF:
				case ENDIF:
				case DEFINE:
				case UNDEF:
				case 65:
				case 132:
				case 133:
				case 135:
				case 136:
				case 137:
				case 138:
				case 139:
				case 140:
				case 141:
				case 142:
				case 143:
				case 144:
				case 145:
				case 146:
				case 147:
				case 148:
				case 150:
				case 151:
				case 152:
				case 154:
				case 156:
				case 157:
				case 158:
				case 159:
				case 170:
				case 177:
				case 178:
				case 195:
				case 202:
					{
					int LA26_3 = input.LA(2);

					if ((EvaluatePredicate(synpred7_cs_fragment)))
					{
						alt26=1;
					}
					else if ((EvaluatePredicate(synpred8_cs_fragment)))
					{
						alt26=2;
					}
					else if ((true))
					{
						alt26=3;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 26, 3, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
					}
					break;
				case 82:
					{
					int LA26_4 = input.LA(2);

					if ((EvaluatePredicate(synpred7_cs_fragment)))
					{
						alt26=1;
					}
					else if ((true))
					{
						alt26=3;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 26, 4, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
					}
					break;
				case 62:
					{
					alt26=4;
					}
					break;
				default:
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 26, 0, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
				}

				} finally { DebugExitDecision(26); }
				switch (alt26)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:114:14: ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+
					{
					DebugLocation(115, 6);
					PushFollow(Follow._object_creation_expression_in_primary_expression819);
					object_creation_expression89=object_creation_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_creation_expression89.Tree);
					DebugLocation(115, 35);
					// cs.g:115:35: ( primary_expression_part )+
					int cnt25=0;
					try { DebugEnterSubRule(25);
					while (true)
					{
						int alt25=2;
						try { DebugEnterDecision(25, decisionCanBacktrack[25]);
						int LA25_0 = input.LA(1);

						if (((LA25_0>=DOT && LA25_0<=PTR)||(LA25_0>=86 && LA25_0<=88)||LA25_0==90))
						{
							alt25=1;
						}


						} finally { DebugExitDecision(25); }
						switch (alt25)
						{
						case 1:
							DebugEnterAlt(1);
							// cs.g:115:35: primary_expression_part
							{
							DebugLocation(115, 35);
							PushFollow(Follow._primary_expression_part_in_primary_expression823);
							primary_expression_part90=primary_expression_part();
							PopFollow();
							if (state.failed) return retval;
							if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression_part90.Tree);

							}
							break;

						default:
							if (cnt25 >= 1)
								goto loop25;

							if (state.backtracking>0) {state.failed=true; return retval;}
							EarlyExitException eee25 = new EarlyExitException( 25, input );
							DebugRecognitionException(eee25);
							throw eee25;
						}
						cnt25++;
					}
					loop25:
						;

					} finally { DebugExitSubRule(25); }


					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:118:7: ( delegate_creation_expression )=> delegate_creation_expression
					{
					DebugLocation(118, 41);
					PushFollow(Follow._delegate_creation_expression_in_primary_expression851);
					delegate_creation_expression91=delegate_creation_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, delegate_creation_expression91.Tree);

					}
					break;
				case 3:
					DebugEnterAlt(3);
					// cs.g:119:7: object_creation_expression
					{
					DebugLocation(119, 7);
					PushFollow(Follow._object_creation_expression_in_primary_expression859);
					object_creation_expression92=object_creation_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_creation_expression92.Tree);

					}
					break;
				case 4:
					DebugEnterAlt(4);
					// cs.g:120:7: anonymous_object_creation_expression
					{
					DebugLocation(120, 7);
					PushFollow(Follow._anonymous_object_creation_expression_in_primary_expression867);
					anonymous_object_creation_expression93=anonymous_object_creation_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_object_creation_expression93.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(26); }


				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:121:4: sizeof_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(121, 4);
				PushFollow(Follow._sizeof_expression_in_primary_expression880);
				sizeof_expression94=sizeof_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, sizeof_expression94.Tree);

				}
				break;
			case 6:
				DebugEnterAlt(6);
				// cs.g:122:4: checked_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(122, 4);
				PushFollow(Follow._checked_expression_in_primary_expression891);
				checked_expression95=checked_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, checked_expression95.Tree);

				}
				break;
			case 7:
				DebugEnterAlt(7);
				// cs.g:123:4: unchecked_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(123, 4);
				PushFollow(Follow._unchecked_expression_in_primary_expression910);
				unchecked_expression96=unchecked_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unchecked_expression96.Tree);

				}
				break;
			case 8:
				DebugEnterAlt(8);
				// cs.g:124:4: default_value_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(124, 4);
				PushFollow(Follow._default_value_expression_in_primary_expression927);
				default_value_expression97=default_value_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, default_value_expression97.Tree);

				}
				break;
			case 9:
				DebugEnterAlt(9);
				// cs.g:125:4: anonymous_method_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(125, 4);
				PushFollow(Follow._anonymous_method_expression_in_primary_expression940);
				anonymous_method_expression98=anonymous_method_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_method_expression98.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("primary_expression", 19);
			LeaveRule("primary_expression", 19);
			Leave_primary_expression();
			if (state.backtracking > 0) { Memoize(input, 19, primary_expression_StartIndex); }
		}
		DebugLocation(126, 1);
		} finally { DebugExitRule(GrammarFileName, "primary_expression"); }
		return retval;

	}
	// $ANTLR end "primary_expression"

	public class primary_expression_start_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_primary_expression_start();
	partial void Leave_primary_expression_start();

	// $ANTLR start "primary_expression_start"
	// cs.g:128:8: public primary_expression_start : ( predefined_type | ( identifier generic_argument_list )=> identifier generic_argument_list | identifier ( '::' identifier )? | 'this' | 'base' | paren_expression | typeof_expression | literal );
	[GrammarRule("primary_expression_start")]
	public csParser.primary_expression_start_return primary_expression_start()
	{
		Enter_primary_expression_start();
		EnterRule("primary_expression_start", 20);
		TraceIn("primary_expression_start", 20);
		csParser.primary_expression_start_return retval = new csParser.primary_expression_start_return();
		retval.Start = (IToken)input.LT(1);
		int primary_expression_start_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal103=null;
		IToken string_literal105=null;
		IToken string_literal106=null;
		csParser.predefined_type_return predefined_type99 = default(csParser.predefined_type_return);
		csParser.identifier_return identifier100 = default(csParser.identifier_return);
		csParser.generic_argument_list_return generic_argument_list101 = default(csParser.generic_argument_list_return);
		csParser.identifier_return identifier102 = default(csParser.identifier_return);
		csParser.identifier_return identifier104 = default(csParser.identifier_return);
		csParser.paren_expression_return paren_expression107 = default(csParser.paren_expression_return);
		csParser.typeof_expression_return typeof_expression108 = default(csParser.typeof_expression_return);
		csParser.literal_return literal109 = default(csParser.literal_return);

		object string_literal103_tree=null;
		object string_literal105_tree=null;
		object string_literal106_tree=null;

		try { DebugEnterRule(GrammarFileName, "primary_expression_start");
		DebugLocation(128, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 20)) { return retval; }
			// cs.g:128:32: ( predefined_type | ( identifier generic_argument_list )=> identifier generic_argument_list | identifier ( '::' identifier )? | 'this' | 'base' | paren_expression | typeof_expression | literal )
			int alt29=8;
			try { DebugEnterDecision(29, decisionCanBacktrack[29]);
			try
			{
				alt29 = dfa29.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(29); }
			switch (alt29)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:129:2: predefined_type
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(129, 2);
				PushFollow(Follow._predefined_type_in_primary_expression_start955);
				predefined_type99=predefined_type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type99.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:130:4: ( identifier generic_argument_list )=> identifier generic_argument_list
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(130, 45);
				PushFollow(Follow._identifier_in_primary_expression_start983);
				identifier100=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier100.Tree);
				DebugLocation(130, 58);
				PushFollow(Follow._generic_argument_list_in_primary_expression_start987);
				generic_argument_list101=generic_argument_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_argument_list101.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:131:4: identifier ( '::' identifier )?
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(131, 4);
				PushFollow(Follow._identifier_in_primary_expression_start992);
				identifier102=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier102.Tree);
				DebugLocation(131, 15);
				// cs.g:131:15: ( '::' identifier )?
				int alt28=2;
				try { DebugEnterSubRule(28);
				try { DebugEnterDecision(28, decisionCanBacktrack[28]);
				int LA28_0 = input.LA(1);

				if ((LA28_0==85))
				{
					alt28=1;
				}
				} finally { DebugExitDecision(28); }
				switch (alt28)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:131:16: '::' identifier
					{
					DebugLocation(131, 16);
					string_literal103=(IToken)Match(input,85,Follow._85_in_primary_expression_start995); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					string_literal103_tree = (object)adaptor.Create(string_literal103);
					adaptor.AddChild(root_0, string_literal103_tree);
					}
					DebugLocation(131, 23);
					PushFollow(Follow._identifier_in_primary_expression_start999);
					identifier104=identifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier104.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(28); }


				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:132:4: 'this'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(132, 4);
				string_literal105=(IToken)Match(input,83,Follow._83_in_primary_expression_start1006); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal105_tree = (object)adaptor.Create(string_literal105);
				adaptor.AddChild(root_0, string_literal105_tree);
				}

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:133:4: 'base'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(133, 4);
				string_literal106=(IToken)Match(input,84,Follow._84_in_primary_expression_start1012); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal106_tree = (object)adaptor.Create(string_literal106);
				adaptor.AddChild(root_0, string_literal106_tree);
				}

				}
				break;
			case 6:
				DebugEnterAlt(6);
				// cs.g:134:4: paren_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(134, 4);
				PushFollow(Follow._paren_expression_in_primary_expression_start1017);
				paren_expression107=paren_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, paren_expression107.Tree);

				}
				break;
			case 7:
				DebugEnterAlt(7);
				// cs.g:135:4: typeof_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(135, 4);
				PushFollow(Follow._typeof_expression_in_primary_expression_start1022);
				typeof_expression108=typeof_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, typeof_expression108.Tree);

				}
				break;
			case 8:
				DebugEnterAlt(8);
				// cs.g:136:4: literal
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(136, 4);
				PushFollow(Follow._literal_in_primary_expression_start1040);
				literal109=literal();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, literal109.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("primary_expression_start", 20);
			LeaveRule("primary_expression_start", 20);
			Leave_primary_expression_start();
			if (state.backtracking > 0) { Memoize(input, 20, primary_expression_start_StartIndex); }
		}
		DebugLocation(137, 1);
		} finally { DebugExitRule(GrammarFileName, "primary_expression_start"); }
		return retval;

	}
	// $ANTLR end "primary_expression_start"

	public class primary_expression_part_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_primary_expression_part();
	partial void Leave_primary_expression_part();

	// $ANTLR start "primary_expression_part"
	// cs.g:139:8: public primary_expression_part : ( access_identifier | brackets_or_arguments | '++' | '--' );
	[GrammarRule("primary_expression_part")]
	public csParser.primary_expression_part_return primary_expression_part()
	{
		Enter_primary_expression_part();
		EnterRule("primary_expression_part", 21);
		TraceIn("primary_expression_part", 21);
		csParser.primary_expression_part_return retval = new csParser.primary_expression_part_return();
		retval.Start = (IToken)input.LT(1);
		int primary_expression_part_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal112=null;
		IToken string_literal113=null;
		csParser.access_identifier_return access_identifier110 = default(csParser.access_identifier_return);
		csParser.brackets_or_arguments_return brackets_or_arguments111 = default(csParser.brackets_or_arguments_return);

		object string_literal112_tree=null;
		object string_literal113_tree=null;

		try { DebugEnterRule(GrammarFileName, "primary_expression_part");
		DebugLocation(139, 8);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 21)) { return retval; }
			// cs.g:139:31: ( access_identifier | brackets_or_arguments | '++' | '--' )
			int alt30=4;
			try { DebugEnterDecision(30, decisionCanBacktrack[30]);
			switch (input.LA(1))
			{
			case DOT:
			case PTR:
				{
				alt30=1;
				}
				break;
			case 88:
			case 90:
				{
				alt30=2;
				}
				break;
			case 86:
				{
				alt30=3;
				}
				break;
			case 87:
				{
				alt30=4;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 30, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(30); }
			switch (alt30)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:140:3: access_identifier
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(140, 3);
				PushFollow(Follow._access_identifier_in_primary_expression_part1053);
				access_identifier110=access_identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, access_identifier110.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:141:4: brackets_or_arguments
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(141, 4);
				PushFollow(Follow._brackets_or_arguments_in_primary_expression_part1058);
				brackets_or_arguments111=brackets_or_arguments();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, brackets_or_arguments111.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:142:4: '++'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(142, 4);
				string_literal112=(IToken)Match(input,86,Follow._86_in_primary_expression_part1064); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal112_tree = (object)adaptor.Create(string_literal112);
				adaptor.AddChild(root_0, string_literal112_tree);
				}

				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:143:4: '--'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(143, 4);
				string_literal113=(IToken)Match(input,87,Follow._87_in_primary_expression_part1069); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal113_tree = (object)adaptor.Create(string_literal113);
				adaptor.AddChild(root_0, string_literal113_tree);
				}

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("primary_expression_part", 21);
			LeaveRule("primary_expression_part", 21);
			Leave_primary_expression_part();
			if (state.backtracking > 0) { Memoize(input, 21, primary_expression_part_StartIndex); }
		}
		DebugLocation(143, 8);
		} finally { DebugExitRule(GrammarFileName, "primary_expression_part"); }
		return retval;

	}
	// $ANTLR end "primary_expression_part"

	public class access_identifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_access_identifier();
	partial void Leave_access_identifier();

	// $ANTLR start "access_identifier"
	// cs.g:144:8: public access_identifier : access_operator type_or_generic ;
	[GrammarRule("access_identifier")]
	public csParser.access_identifier_return access_identifier()
	{
		Enter_access_identifier();
		EnterRule("access_identifier", 22);
		TraceIn("access_identifier", 22);
		csParser.access_identifier_return retval = new csParser.access_identifier_return();
		retval.Start = (IToken)input.LT(1);
		int access_identifier_StartIndex = input.Index;
		object root_0 = null;

		csParser.access_operator_return access_operator114 = default(csParser.access_operator_return);
		csParser.type_or_generic_return type_or_generic115 = default(csParser.type_or_generic_return);


		try { DebugEnterRule(GrammarFileName, "access_identifier");
		DebugLocation(144, 35);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 22)) { return retval; }
			// cs.g:144:25: ( access_operator type_or_generic )
			DebugEnterAlt(1);
			// cs.g:145:2: access_operator type_or_generic
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(145, 2);
			PushFollow(Follow._access_operator_in_access_identifier1079);
			access_operator114=access_operator();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, access_operator114.Tree);
			DebugLocation(145, 20);
			PushFollow(Follow._type_or_generic_in_access_identifier1083);
			type_or_generic115=type_or_generic();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic115.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("access_identifier", 22);
			LeaveRule("access_identifier", 22);
			Leave_access_identifier();
			if (state.backtracking > 0) { Memoize(input, 22, access_identifier_StartIndex); }
		}
		DebugLocation(145, 35);
		} finally { DebugExitRule(GrammarFileName, "access_identifier"); }
		return retval;

	}
	// $ANTLR end "access_identifier"

	public class access_operator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_access_operator();
	partial void Leave_access_operator();

	// $ANTLR start "access_operator"
	// cs.g:146:8: public access_operator : ( '.' | '->' );
	[GrammarRule("access_operator")]
	public csParser.access_operator_return access_operator()
	{
		Enter_access_operator();
		EnterRule("access_operator", 23);
		TraceIn("access_operator", 23);
		csParser.access_operator_return retval = new csParser.access_operator_return();
		retval.Start = (IToken)input.LT(1);
		int access_operator_StartIndex = input.Index;
		object root_0 = null;

		IToken set116=null;

		object set116_tree=null;

		try { DebugEnterRule(GrammarFileName, "access_operator");
		DebugLocation(146, 14);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 23)) { return retval; }
			// cs.g:146:23: ( '.' | '->' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(146, 23);
			set116=(IToken)input.LT(1);
			if ((input.LA(1)>=DOT && input.LA(1)<=PTR))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set116));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("access_operator", 23);
			LeaveRule("access_operator", 23);
			Leave_access_operator();
			if (state.backtracking > 0) { Memoize(input, 23, access_operator_StartIndex); }
		}
		DebugLocation(147, 14);
		} finally { DebugExitRule(GrammarFileName, "access_operator"); }
		return retval;

	}
	// $ANTLR end "access_operator"

	public class brackets_or_arguments_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_brackets_or_arguments();
	partial void Leave_brackets_or_arguments();

	// $ANTLR start "brackets_or_arguments"
	// cs.g:148:8: public brackets_or_arguments : ( brackets | arguments );
	[GrammarRule("brackets_or_arguments")]
	public csParser.brackets_or_arguments_return brackets_or_arguments()
	{
		Enter_brackets_or_arguments();
		EnterRule("brackets_or_arguments", 24);
		TraceIn("brackets_or_arguments", 24);
		csParser.brackets_or_arguments_return retval = new csParser.brackets_or_arguments_return();
		retval.Start = (IToken)input.LT(1);
		int brackets_or_arguments_StartIndex = input.Index;
		object root_0 = null;

		csParser.brackets_return brackets117 = default(csParser.brackets_return);
		csParser.arguments_return arguments118 = default(csParser.arguments_return);


		try { DebugEnterRule(GrammarFileName, "brackets_or_arguments");
		DebugLocation(148, 22);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 24)) { return retval; }
			// cs.g:148:29: ( brackets | arguments )
			int alt31=2;
			try { DebugEnterDecision(31, decisionCanBacktrack[31]);
			int LA31_0 = input.LA(1);

			if ((LA31_0==88))
			{
				alt31=1;
			}
			else if ((LA31_0==90))
			{
				alt31=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 31, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(31); }
			switch (alt31)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:149:2: brackets
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(149, 2);
				PushFollow(Follow._brackets_in_brackets_or_arguments1109);
				brackets117=brackets();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, brackets117.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:149:13: arguments
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(149, 13);
				PushFollow(Follow._arguments_in_brackets_or_arguments1113);
				arguments118=arguments();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments118.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("brackets_or_arguments", 24);
			LeaveRule("brackets_or_arguments", 24);
			Leave_brackets_or_arguments();
			if (state.backtracking > 0) { Memoize(input, 24, brackets_or_arguments_StartIndex); }
		}
		DebugLocation(149, 22);
		} finally { DebugExitRule(GrammarFileName, "brackets_or_arguments"); }
		return retval;

	}
	// $ANTLR end "brackets_or_arguments"

	public class brackets_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_brackets();
	partial void Leave_brackets();

	// $ANTLR start "brackets"
	// cs.g:150:8: public brackets : '[' ( expression_list )? ']' ;
	[GrammarRule("brackets")]
	public csParser.brackets_return brackets()
	{
		Enter_brackets();
		EnterRule("brackets", 25);
		TraceIn("brackets", 25);
		csParser.brackets_return retval = new csParser.brackets_return();
		retval.Start = (IToken)input.LT(1);
		int brackets_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal119=null;
		IToken char_literal121=null;
		csParser.expression_list_return expression_list120 = default(csParser.expression_list_return);

		object char_literal119_tree=null;
		object char_literal121_tree=null;

		try { DebugEnterRule(GrammarFileName, "brackets");
		DebugLocation(150, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 25)) { return retval; }
			// cs.g:150:16: ( '[' ( expression_list )? ']' )
			DebugEnterAlt(1);
			// cs.g:151:2: '[' ( expression_list )? ']'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(151, 2);
			char_literal119=(IToken)Match(input,88,Follow._88_in_brackets1123); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal119_tree = (object)adaptor.Create(char_literal119);
			adaptor.AddChild(root_0, char_literal119_tree);
			}
			DebugLocation(151, 8);
			// cs.g:151:8: ( expression_list )?
			int alt32=2;
			try { DebugEnterSubRule(32);
			try { DebugEnterDecision(32, decisionCanBacktrack[32]);
			int LA32_0 = input.LA(1);

			if (((LA32_0>=IDENTIFIER && LA32_0<=NULL)||LA32_0==MINUS||(LA32_0>=ELIF && LA32_0<=UNDEF)||LA32_0==65||LA32_0==68||(LA32_0>=83 && LA32_0<=84)||(LA32_0>=86 && LA32_0<=87)||LA32_0==90||(LA32_0>=95 && LA32_0<=100)||LA32_0==102||(LA32_0>=104 && LA32_0<=106)||LA32_0==117||(LA32_0>=132 && LA32_0<=133)||(LA32_0>=135 && LA32_0<=148)||(LA32_0>=150 && LA32_0<=152)||LA32_0==154||(LA32_0>=156 && LA32_0<=168)||LA32_0==170||(LA32_0>=177 && LA32_0<=178)||(LA32_0>=195 && LA32_0<=202)))
			{
				alt32=1;
			}
			} finally { DebugExitDecision(32); }
			switch (alt32)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:151:8: expression_list
				{
				DebugLocation(151, 8);
				PushFollow(Follow._expression_list_in_brackets1127);
				expression_list120=expression_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression_list120.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(32); }

			DebugLocation(151, 27);
			char_literal121=(IToken)Match(input,89,Follow._89_in_brackets1132); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal121_tree = (object)adaptor.Create(char_literal121);
			adaptor.AddChild(root_0, char_literal121_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("brackets", 25);
			LeaveRule("brackets", 25);
			Leave_brackets();
			if (state.backtracking > 0) { Memoize(input, 25, brackets_StartIndex); }
		}
		DebugLocation(151, 30);
		} finally { DebugExitRule(GrammarFileName, "brackets"); }
		return retval;

	}
	// $ANTLR end "brackets"

	public class paren_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_paren_expression();
	partial void Leave_paren_expression();

	// $ANTLR start "paren_expression"
	// cs.g:152:8: public paren_expression : '(' expression ')' ;
	[GrammarRule("paren_expression")]
	public csParser.paren_expression_return paren_expression()
	{
		Enter_paren_expression();
		EnterRule("paren_expression", 26);
		TraceIn("paren_expression", 26);
		csParser.paren_expression_return retval = new csParser.paren_expression_return();
		retval.Start = (IToken)input.LT(1);
		int paren_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal122=null;
		IToken char_literal124=null;
		csParser.expression_return expression123 = default(csParser.expression_return);

		object char_literal122_tree=null;
		object char_literal124_tree=null;

		try { DebugEnterRule(GrammarFileName, "paren_expression");
		DebugLocation(152, 24);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 26)) { return retval; }
			// cs.g:152:24: ( '(' expression ')' )
			DebugEnterAlt(1);
			// cs.g:153:2: '(' expression ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(153, 2);
			char_literal122=(IToken)Match(input,90,Follow._90_in_paren_expression1144); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal122_tree = (object)adaptor.Create(char_literal122);
			adaptor.AddChild(root_0, char_literal122_tree);
			}
			DebugLocation(153, 8);
			PushFollow(Follow._expression_in_paren_expression1148);
			expression123=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression123.Tree);
			DebugLocation(153, 21);
			char_literal124=(IToken)Match(input,RPAREN,Follow._RPAREN_in_paren_expression1152); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal124_tree = (object)adaptor.Create(char_literal124);
			adaptor.AddChild(root_0, char_literal124_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("paren_expression", 26);
			LeaveRule("paren_expression", 26);
			Leave_paren_expression();
			if (state.backtracking > 0) { Memoize(input, 26, paren_expression_StartIndex); }
		}
		DebugLocation(153, 24);
		} finally { DebugExitRule(GrammarFileName, "paren_expression"); }
		return retval;

	}
	// $ANTLR end "paren_expression"

	public class arguments_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_arguments();
	partial void Leave_arguments();

	// $ANTLR start "arguments"
	// cs.g:154:8: public arguments : '(' ( argument_list )? ')' ;
	[GrammarRule("arguments")]
	public csParser.arguments_return arguments()
	{
		Enter_arguments();
		EnterRule("arguments", 27);
		TraceIn("arguments", 27);
		csParser.arguments_return retval = new csParser.arguments_return();
		retval.Start = (IToken)input.LT(1);
		int arguments_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal125=null;
		IToken char_literal127=null;
		csParser.argument_list_return argument_list126 = default(csParser.argument_list_return);

		object char_literal125_tree=null;
		object char_literal127_tree=null;

		try { DebugEnterRule(GrammarFileName, "arguments");
		DebugLocation(154, 28);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 27)) { return retval; }
			// cs.g:154:17: ( '(' ( argument_list )? ')' )
			DebugEnterAlt(1);
			// cs.g:155:2: '(' ( argument_list )? ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(155, 2);
			char_literal125=(IToken)Match(input,90,Follow._90_in_arguments1163); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal125_tree = (object)adaptor.Create(char_literal125);
			adaptor.AddChild(root_0, char_literal125_tree);
			}
			DebugLocation(155, 8);
			// cs.g:155:8: ( argument_list )?
			int alt33=2;
			try { DebugEnterSubRule(33);
			try { DebugEnterDecision(33, decisionCanBacktrack[33]);
			int LA33_0 = input.LA(1);

			if (((LA33_0>=IDENTIFIER && LA33_0<=NULL)||LA33_0==MINUS||(LA33_0>=ELIF && LA33_0<=UNDEF)||LA33_0==65||LA33_0==68||(LA33_0>=83 && LA33_0<=84)||(LA33_0>=86 && LA33_0<=87)||LA33_0==90||(LA33_0>=93 && LA33_0<=100)||LA33_0==102||(LA33_0>=104 && LA33_0<=106)||LA33_0==117||(LA33_0>=132 && LA33_0<=133)||(LA33_0>=135 && LA33_0<=148)||(LA33_0>=150 && LA33_0<=152)||LA33_0==154||(LA33_0>=156 && LA33_0<=168)||LA33_0==170||(LA33_0>=177 && LA33_0<=178)||(LA33_0>=195 && LA33_0<=202)))
			{
				alt33=1;
			}
			} finally { DebugExitDecision(33); }
			switch (alt33)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:155:8: argument_list
				{
				DebugLocation(155, 8);
				PushFollow(Follow._argument_list_in_arguments1167);
				argument_list126=argument_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_list126.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(33); }

			DebugLocation(155, 25);
			char_literal127=(IToken)Match(input,RPAREN,Follow._RPAREN_in_arguments1172); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal127_tree = (object)adaptor.Create(char_literal127);
			adaptor.AddChild(root_0, char_literal127_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("arguments", 27);
			LeaveRule("arguments", 27);
			Leave_arguments();
			if (state.backtracking > 0) { Memoize(input, 27, arguments_StartIndex); }
		}
		DebugLocation(155, 28);
		} finally { DebugExitRule(GrammarFileName, "arguments"); }
		return retval;

	}
	// $ANTLR end "arguments"

	public class argument_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_argument_list();
	partial void Leave_argument_list();

	// $ANTLR start "argument_list"
	// cs.g:156:8: public argument_list : argument ( ',' argument )* ;
	[GrammarRule("argument_list")]
	public csParser.argument_list_return argument_list()
	{
		Enter_argument_list();
		EnterRule("argument_list", 28);
		TraceIn("argument_list", 28);
		csParser.argument_list_return retval = new csParser.argument_list_return();
		retval.Start = (IToken)input.LT(1);
		int argument_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal129=null;
		csParser.argument_return argument128 = default(csParser.argument_return);
		csParser.argument_return argument130 = default(csParser.argument_return);

		object char_literal129_tree=null;

		try { DebugEnterRule(GrammarFileName, "argument_list");
		DebugLocation(156, 25);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 28)) { return retval; }
			// cs.g:156:21: ( argument ( ',' argument )* )
			DebugEnterAlt(1);
			// cs.g:157:2: argument ( ',' argument )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(157, 2);
			PushFollow(Follow._argument_in_argument_list1183);
			argument128=argument();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument128.Tree);
			DebugLocation(157, 11);
			// cs.g:157:11: ( ',' argument )*
			try { DebugEnterSubRule(34);
			while (true)
			{
				int alt34=2;
				try { DebugEnterDecision(34, decisionCanBacktrack[34]);
				int LA34_0 = input.LA(1);

				if ((LA34_0==91))
				{
					alt34=1;
				}


				} finally { DebugExitDecision(34); }
				switch ( alt34 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:157:12: ',' argument
					{
					DebugLocation(157, 12);
					char_literal129=(IToken)Match(input,91,Follow._91_in_argument_list1186); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal129_tree = (object)adaptor.Create(char_literal129);
					adaptor.AddChild(root_0, char_literal129_tree);
					}
					DebugLocation(157, 16);
					PushFollow(Follow._argument_in_argument_list1188);
					argument130=argument();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument130.Tree);

					}
					break;

				default:
					goto loop34;
				}
			}

			loop34:
				;

			} finally { DebugExitSubRule(34); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("argument_list", 28);
			LeaveRule("argument_list", 28);
			Leave_argument_list();
			if (state.backtracking > 0) { Memoize(input, 28, argument_list_StartIndex); }
		}
		DebugLocation(157, 25);
		} finally { DebugExitRule(GrammarFileName, "argument_list"); }
		return retval;

	}
	// $ANTLR end "argument_list"

	public class argument_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_argument();
	partial void Leave_argument();

	// $ANTLR start "argument"
	// cs.g:159:8: public argument : ( argument_name argument_value | argument_value );
	[GrammarRule("argument")]
	public csParser.argument_return argument()
	{
		Enter_argument();
		EnterRule("argument", 29);
		TraceIn("argument", 29);
		csParser.argument_return retval = new csParser.argument_return();
		retval.Start = (IToken)input.LT(1);
		int argument_StartIndex = input.Index;
		object root_0 = null;

		csParser.argument_name_return argument_name131 = default(csParser.argument_name_return);
		csParser.argument_value_return argument_value132 = default(csParser.argument_value_return);
		csParser.argument_value_return argument_value133 = default(csParser.argument_value_return);


		try { DebugEnterRule(GrammarFileName, "argument");
		DebugLocation(159, 17);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 29)) { return retval; }
			// cs.g:159:16: ( argument_name argument_value | argument_value )
			int alt35=2;
			try { DebugEnterDecision(35, decisionCanBacktrack[35]);
			switch (input.LA(1))
			{
			case IDENTIFIER:
				{
				int LA35_1 = input.LA(2);

				if ((LA35_1==92))
				{
					alt35=1;
				}
				else if (((LA35_1>=DOT && LA35_1<=GT)||LA35_1==RPAREN||LA35_1==66||(LA35_1>=85 && LA35_1<=88)||(LA35_1>=90 && LA35_1<=91)||(LA35_1>=101 && LA35_1<=104)||(LA35_1>=107 && LA35_1<=131)))
				{
					alt35=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 35, 1, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case 133:
				{
				int LA35_2 = input.LA(2);

				if ((LA35_2==92))
				{
					alt35=1;
				}
				else if ((LA35_2==IDENTIFIER||(LA35_2>=DOT && LA35_2<=GT)||(LA35_2>=ELIF && LA35_2<=UNDEF)||LA35_2==RPAREN||(LA35_2>=65 && LA35_2<=66)||LA35_2==82||(LA35_2>=85 && LA35_2<=88)||(LA35_2>=90 && LA35_2<=91)||(LA35_2>=101 && LA35_2<=104)||(LA35_2>=107 && LA35_2<=133)||(LA35_2>=135 && LA35_2<=148)||(LA35_2>=150 && LA35_2<=152)||LA35_2==154||(LA35_2>=156 && LA35_2<=168)||LA35_2==170||(LA35_2>=177 && LA35_2<=178)||(LA35_2>=195 && LA35_2<=202)))
				{
					alt35=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 35, 2, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case Real_literal:
			case NUMBER:
			case Hex_number:
			case Character_literal:
			case STRINGLITERAL:
			case Verbatim_string_literal:
			case TRUE:
			case FALSE:
			case NULL:
			case MINUS:
			case 68:
			case 83:
			case 84:
			case 86:
			case 87:
			case 90:
			case 93:
			case 94:
			case 95:
			case 96:
			case 97:
			case 98:
			case 99:
			case 100:
			case 102:
			case 104:
			case 105:
			case 106:
			case 117:
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 196:
			case 197:
			case 198:
			case 199:
			case 200:
			case 201:
				{
				alt35=2;
				}
				break;
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 132:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 170:
			case 177:
			case 178:
			case 195:
			case 202:
				{
				int LA35_4 = input.LA(2);

				if ((LA35_4==92))
				{
					alt35=1;
				}
				else if (((LA35_4>=DOT && LA35_4<=GT)||LA35_4==RPAREN||LA35_4==66||(LA35_4>=85 && LA35_4<=88)||(LA35_4>=90 && LA35_4<=91)||(LA35_4>=101 && LA35_4<=104)||(LA35_4>=107 && LA35_4<=131)))
				{
					alt35=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 35, 4, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 35, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(35); }
			switch (alt35)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:160:2: argument_name argument_value
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(160, 2);
				PushFollow(Follow._argument_name_in_argument1200);
				argument_name131=argument_name();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_name131.Tree);
				DebugLocation(160, 18);
				PushFollow(Follow._argument_value_in_argument1204);
				argument_value132=argument_value();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_value132.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:161:4: argument_value
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(161, 4);
				PushFollow(Follow._argument_value_in_argument1209);
				argument_value133=argument_value();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_value133.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("argument", 29);
			LeaveRule("argument", 29);
			Leave_argument();
			if (state.backtracking > 0) { Memoize(input, 29, argument_StartIndex); }
		}
		DebugLocation(161, 17);
		} finally { DebugExitRule(GrammarFileName, "argument"); }
		return retval;

	}
	// $ANTLR end "argument"

	public class argument_name_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_argument_name();
	partial void Leave_argument_name();

	// $ANTLR start "argument_name"
	// cs.g:162:8: public argument_name : identifier ':' ;
	[GrammarRule("argument_name")]
	public csParser.argument_name_return argument_name()
	{
		Enter_argument_name();
		EnterRule("argument_name", 30);
		TraceIn("argument_name", 30);
		csParser.argument_name_return retval = new csParser.argument_name_return();
		retval.Start = (IToken)input.LT(1);
		int argument_name_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal135=null;
		csParser.identifier_return identifier134 = default(csParser.identifier_return);

		object char_literal135_tree=null;

		try { DebugEnterRule(GrammarFileName, "argument_name");
		DebugLocation(162, 17);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 30)) { return retval; }
			// cs.g:162:21: ( identifier ':' )
			DebugEnterAlt(1);
			// cs.g:163:2: identifier ':'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(163, 2);
			PushFollow(Follow._identifier_in_argument_name1218);
			identifier134=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier134.Tree);
			DebugLocation(163, 15);
			char_literal135=(IToken)Match(input,92,Follow._92_in_argument_name1222); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal135_tree = (object)adaptor.Create(char_literal135);
			adaptor.AddChild(root_0, char_literal135_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("argument_name", 30);
			LeaveRule("argument_name", 30);
			Leave_argument_name();
			if (state.backtracking > 0) { Memoize(input, 30, argument_name_StartIndex); }
		}
		DebugLocation(163, 17);
		} finally { DebugExitRule(GrammarFileName, "argument_name"); }
		return retval;

	}
	// $ANTLR end "argument_name"

	public class argument_value_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_argument_value();
	partial void Leave_argument_value();

	// $ANTLR start "argument_value"
	// cs.g:164:8: public argument_value : ( expression | ref_variable_reference | 'out' variable_reference );
	[GrammarRule("argument_value")]
	public csParser.argument_value_return argument_value()
	{
		Enter_argument_value();
		EnterRule("argument_value", 31);
		TraceIn("argument_value", 31);
		csParser.argument_value_return retval = new csParser.argument_value_return();
		retval.Start = (IToken)input.LT(1);
		int argument_value_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal138=null;
		csParser.expression_return expression136 = default(csParser.expression_return);
		csParser.ref_variable_reference_return ref_variable_reference137 = default(csParser.ref_variable_reference_return);
		csParser.variable_reference_return variable_reference139 = default(csParser.variable_reference_return);

		object string_literal138_tree=null;

		try { DebugEnterRule(GrammarFileName, "argument_value");
		DebugLocation(164, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 31)) { return retval; }
			// cs.g:164:22: ( expression | ref_variable_reference | 'out' variable_reference )
			int alt36=3;
			try { DebugEnterDecision(36, decisionCanBacktrack[36]);
			switch (input.LA(1))
			{
			case IDENTIFIER:
			case Real_literal:
			case NUMBER:
			case Hex_number:
			case Character_literal:
			case STRINGLITERAL:
			case Verbatim_string_literal:
			case TRUE:
			case FALSE:
			case NULL:
			case MINUS:
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 68:
			case 83:
			case 84:
			case 86:
			case 87:
			case 90:
			case 95:
			case 96:
			case 97:
			case 98:
			case 99:
			case 100:
			case 102:
			case 104:
			case 105:
			case 106:
			case 117:
			case 132:
			case 133:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 170:
			case 177:
			case 178:
			case 195:
			case 196:
			case 197:
			case 198:
			case 199:
			case 200:
			case 201:
			case 202:
				{
				alt36=1;
				}
				break;
			case 94:
				{
				alt36=2;
				}
				break;
			case 93:
				{
				alt36=3;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 36, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(36); }
			switch (alt36)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:165:2: expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(165, 2);
				PushFollow(Follow._expression_in_argument_value1232);
				expression136=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression136.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:166:4: ref_variable_reference
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(166, 4);
				PushFollow(Follow._ref_variable_reference_in_argument_value1238);
				ref_variable_reference137=ref_variable_reference();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ref_variable_reference137.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:167:4: 'out' variable_reference
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(167, 4);
				string_literal138=(IToken)Match(input,93,Follow._93_in_argument_value1244); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal138_tree = (object)adaptor.Create(string_literal138);
				adaptor.AddChild(root_0, string_literal138_tree);
				}
				DebugLocation(167, 12);
				PushFollow(Follow._variable_reference_in_argument_value1248);
				variable_reference139=variable_reference();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_reference139.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("argument_value", 31);
			LeaveRule("argument_value", 31);
			Leave_argument_value();
			if (state.backtracking > 0) { Memoize(input, 31, argument_value_StartIndex); }
		}
		DebugLocation(167, 30);
		} finally { DebugExitRule(GrammarFileName, "argument_value"); }
		return retval;

	}
	// $ANTLR end "argument_value"

	public class ref_variable_reference_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_ref_variable_reference();
	partial void Leave_ref_variable_reference();

	// $ANTLR start "ref_variable_reference"
	// cs.g:168:8: public ref_variable_reference : 'ref' ( ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference ) | variable_reference ) ;
	[GrammarRule("ref_variable_reference")]
	public csParser.ref_variable_reference_return ref_variable_reference()
	{
		Enter_ref_variable_reference();
		EnterRule("ref_variable_reference", 32);
		TraceIn("ref_variable_reference", 32);
		csParser.ref_variable_reference_return retval = new csParser.ref_variable_reference_return();
		retval.Start = (IToken)input.LT(1);
		int ref_variable_reference_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal140=null;
		IToken char_literal141=null;
		IToken char_literal143=null;
		csParser.type_return type142 = default(csParser.type_return);
		csParser.ref_variable_reference_return ref_variable_reference144 = default(csParser.ref_variable_reference_return);
		csParser.variable_reference_return variable_reference145 = default(csParser.variable_reference_return);
		csParser.variable_reference_return variable_reference146 = default(csParser.variable_reference_return);

		object string_literal140_tree=null;
		object char_literal141_tree=null;
		object char_literal143_tree=null;

		try { DebugEnterRule(GrammarFileName, "ref_variable_reference");
		DebugLocation(168, 23);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 32)) { return retval; }
			// cs.g:168:30: ( 'ref' ( ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference ) | variable_reference ) )
			DebugEnterAlt(1);
			// cs.g:169:2: 'ref' ( ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference ) | variable_reference )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(169, 2);
			string_literal140=(IToken)Match(input,94,Follow._94_in_ref_variable_reference1258); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal140_tree = (object)adaptor.Create(string_literal140);
			adaptor.AddChild(root_0, string_literal140_tree);
			}
			DebugLocation(170, 3);
			// cs.g:170:3: ( ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference ) | variable_reference )
			int alt38=2;
			try { DebugEnterSubRule(38);
			try { DebugEnterDecision(38, decisionCanBacktrack[38]);
			try
			{
				alt38 = dfa38.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(38); }
			switch (alt38)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:170:4: ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference )
				{
				DebugLocation(170, 28);
				char_literal141=(IToken)Match(input,90,Follow._90_in_ref_variable_reference1280); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal141_tree = (object)adaptor.Create(char_literal141);
				adaptor.AddChild(root_0, char_literal141_tree);
				}
				DebugLocation(170, 34);
				PushFollow(Follow._type_in_ref_variable_reference1284);
				type142=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type142.Tree);
				DebugLocation(170, 41);
				char_literal143=(IToken)Match(input,RPAREN,Follow._RPAREN_in_ref_variable_reference1288); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal143_tree = (object)adaptor.Create(char_literal143);
				adaptor.AddChild(root_0, char_literal143_tree);
				}
				DebugLocation(170, 47);
				// cs.g:170:47: ( ref_variable_reference | variable_reference )
				int alt37=2;
				try { DebugEnterSubRule(37);
				try { DebugEnterDecision(37, decisionCanBacktrack[37]);
				int LA37_0 = input.LA(1);

				if ((LA37_0==94))
				{
					alt37=1;
				}
				else if (((LA37_0>=IDENTIFIER && LA37_0<=NULL)||LA37_0==MINUS||(LA37_0>=ELIF && LA37_0<=UNDEF)||LA37_0==65||LA37_0==68||(LA37_0>=83 && LA37_0<=84)||(LA37_0>=86 && LA37_0<=87)||LA37_0==90||(LA37_0>=95 && LA37_0<=100)||LA37_0==102||(LA37_0>=104 && LA37_0<=106)||LA37_0==117||(LA37_0>=132 && LA37_0<=133)||(LA37_0>=135 && LA37_0<=148)||(LA37_0>=150 && LA37_0<=152)||LA37_0==154||(LA37_0>=156 && LA37_0<=168)||LA37_0==170||(LA37_0>=177 && LA37_0<=178)||(LA37_0>=195 && LA37_0<=202)))
				{
					alt37=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 37, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				} finally { DebugExitDecision(37); }
				switch (alt37)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:170:48: ref_variable_reference
					{
					DebugLocation(170, 48);
					PushFollow(Follow._ref_variable_reference_in_ref_variable_reference1293);
					ref_variable_reference144=ref_variable_reference();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ref_variable_reference144.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:170:73: variable_reference
					{
					DebugLocation(170, 73);
					PushFollow(Follow._variable_reference_in_ref_variable_reference1297);
					variable_reference145=variable_reference();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_reference145.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(37); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:172:5: variable_reference
				{
				DebugLocation(172, 5);
				PushFollow(Follow._variable_reference_in_ref_variable_reference1333);
				variable_reference146=variable_reference();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_reference146.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(38); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("ref_variable_reference", 32);
			LeaveRule("ref_variable_reference", 32);
			Leave_ref_variable_reference();
			if (state.backtracking > 0) { Memoize(input, 32, ref_variable_reference_StartIndex); }
		}
		DebugLocation(172, 23);
		} finally { DebugExitRule(GrammarFileName, "ref_variable_reference"); }
		return retval;

	}
	// $ANTLR end "ref_variable_reference"

	public class variable_reference_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_variable_reference();
	partial void Leave_variable_reference();

	// $ANTLR start "variable_reference"
	// cs.g:174:8: public variable_reference : expression ;
	[GrammarRule("variable_reference")]
	public csParser.variable_reference_return variable_reference()
	{
		Enter_variable_reference();
		EnterRule("variable_reference", 33);
		TraceIn("variable_reference", 33);
		csParser.variable_reference_return retval = new csParser.variable_reference_return();
		retval.Start = (IToken)input.LT(1);
		int variable_reference_StartIndex = input.Index;
		object root_0 = null;

		csParser.expression_return expression147 = default(csParser.expression_return);


		try { DebugEnterRule(GrammarFileName, "variable_reference");
		DebugLocation(174, 11);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 33)) { return retval; }
			// cs.g:174:26: ( expression )
			DebugEnterAlt(1);
			// cs.g:175:2: expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(175, 2);
			PushFollow(Follow._expression_in_variable_reference1345);
			expression147=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression147.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("variable_reference", 33);
			LeaveRule("variable_reference", 33);
			Leave_variable_reference();
			if (state.backtracking > 0) { Memoize(input, 33, variable_reference_StartIndex); }
		}
		DebugLocation(175, 11);
		} finally { DebugExitRule(GrammarFileName, "variable_reference"); }
		return retval;

	}
	// $ANTLR end "variable_reference"

	public class rank_specifiers_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_rank_specifiers();
	partial void Leave_rank_specifiers();

	// $ANTLR start "rank_specifiers"
	// cs.g:176:8: public rank_specifiers : ( rank_specifier )+ ;
	[GrammarRule("rank_specifiers")]
	public csParser.rank_specifiers_return rank_specifiers()
	{
		Enter_rank_specifiers();
		EnterRule("rank_specifiers", 34);
		TraceIn("rank_specifiers", 34);
		csParser.rank_specifiers_return retval = new csParser.rank_specifiers_return();
		retval.Start = (IToken)input.LT(1);
		int rank_specifiers_StartIndex = input.Index;
		object root_0 = null;

		csParser.rank_specifier_return rank_specifier148 = default(csParser.rank_specifier_return);


		try { DebugEnterRule(GrammarFileName, "rank_specifiers");
		DebugLocation(176, 17);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 34)) { return retval; }
			// cs.g:176:23: ( ( rank_specifier )+ )
			DebugEnterAlt(1);
			// cs.g:177:2: ( rank_specifier )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(177, 2);
			// cs.g:177:2: ( rank_specifier )+
			int cnt39=0;
			try { DebugEnterSubRule(39);
			while (true)
			{
				int alt39=2;
				try { DebugEnterDecision(39, decisionCanBacktrack[39]);
				int LA39_0 = input.LA(1);

				if ((LA39_0==88))
				{
					int LA39_2 = input.LA(2);

					if ((LA39_2==89||LA39_2==91))
					{
						alt39=1;
					}


				}


				} finally { DebugExitDecision(39); }
				switch (alt39)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:177:2: rank_specifier
					{
					DebugLocation(177, 2);
					PushFollow(Follow._rank_specifier_in_rank_specifiers1355);
					rank_specifier148=rank_specifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, rank_specifier148.Tree);

					}
					break;

				default:
					if (cnt39 >= 1)
						goto loop39;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee39 = new EarlyExitException( 39, input );
					DebugRecognitionException(eee39);
					throw eee39;
				}
				cnt39++;
			}
			loop39:
				;

			} finally { DebugExitSubRule(39); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("rank_specifiers", 34);
			LeaveRule("rank_specifiers", 34);
			Leave_rank_specifiers();
			if (state.backtracking > 0) { Memoize(input, 34, rank_specifiers_StartIndex); }
		}
		DebugLocation(177, 17);
		} finally { DebugExitRule(GrammarFileName, "rank_specifiers"); }
		return retval;

	}
	// $ANTLR end "rank_specifiers"

	public class rank_specifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_rank_specifier();
	partial void Leave_rank_specifier();

	// $ANTLR start "rank_specifier"
	// cs.g:178:8: public rank_specifier : '[' ( dim_separators )? ']' ;
	[GrammarRule("rank_specifier")]
	public csParser.rank_specifier_return rank_specifier()
	{
		Enter_rank_specifier();
		EnterRule("rank_specifier", 35);
		TraceIn("rank_specifier", 35);
		csParser.rank_specifier_return retval = new csParser.rank_specifier_return();
		retval.Start = (IToken)input.LT(1);
		int rank_specifier_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal149=null;
		IToken char_literal151=null;
		csParser.dim_separators_return dim_separators150 = default(csParser.dim_separators_return);

		object char_literal149_tree=null;
		object char_literal151_tree=null;

		try { DebugEnterRule(GrammarFileName, "rank_specifier");
		DebugLocation(178, 29);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 35)) { return retval; }
			// cs.g:178:22: ( '[' ( dim_separators )? ']' )
			DebugEnterAlt(1);
			// cs.g:179:2: '[' ( dim_separators )? ']'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(179, 2);
			char_literal149=(IToken)Match(input,88,Follow._88_in_rank_specifier1375); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal149_tree = (object)adaptor.Create(char_literal149);
			adaptor.AddChild(root_0, char_literal149_tree);
			}
			DebugLocation(179, 8);
			// cs.g:179:8: ( dim_separators )?
			int alt40=2;
			try { DebugEnterSubRule(40);
			try { DebugEnterDecision(40, decisionCanBacktrack[40]);
			int LA40_0 = input.LA(1);

			if ((LA40_0==91))
			{
				alt40=1;
			}
			} finally { DebugExitDecision(40); }
			switch (alt40)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:179:8: dim_separators
				{
				DebugLocation(179, 8);
				PushFollow(Follow._dim_separators_in_rank_specifier1379);
				dim_separators150=dim_separators();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, dim_separators150.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(40); }

			DebugLocation(179, 26);
			char_literal151=(IToken)Match(input,89,Follow._89_in_rank_specifier1384); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal151_tree = (object)adaptor.Create(char_literal151);
			adaptor.AddChild(root_0, char_literal151_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("rank_specifier", 35);
			LeaveRule("rank_specifier", 35);
			Leave_rank_specifier();
			if (state.backtracking > 0) { Memoize(input, 35, rank_specifier_StartIndex); }
		}
		DebugLocation(179, 29);
		} finally { DebugExitRule(GrammarFileName, "rank_specifier"); }
		return retval;

	}
	// $ANTLR end "rank_specifier"

	public class dim_separators_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_dim_separators();
	partial void Leave_dim_separators();

	// $ANTLR start "dim_separators"
	// cs.g:180:8: public dim_separators : ( ',' )+ ;
	[GrammarRule("dim_separators")]
	public csParser.dim_separators_return dim_separators()
	{
		Enter_dim_separators();
		EnterRule("dim_separators", 36);
		TraceIn("dim_separators", 36);
		csParser.dim_separators_return retval = new csParser.dim_separators_return();
		retval.Start = (IToken)input.LT(1);
		int dim_separators_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal152=null;

		object char_literal152_tree=null;

		try { DebugEnterRule(GrammarFileName, "dim_separators");
		DebugLocation(180, 6);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 36)) { return retval; }
			// cs.g:180:22: ( ( ',' )+ )
			DebugEnterAlt(1);
			// cs.g:181:2: ( ',' )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(181, 2);
			// cs.g:181:2: ( ',' )+
			int cnt41=0;
			try { DebugEnterSubRule(41);
			while (true)
			{
				int alt41=2;
				try { DebugEnterDecision(41, decisionCanBacktrack[41]);
				int LA41_0 = input.LA(1);

				if ((LA41_0==91))
				{
					alt41=1;
				}


				} finally { DebugExitDecision(41); }
				switch (alt41)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:181:2: ','
					{
					DebugLocation(181, 2);
					char_literal152=(IToken)Match(input,91,Follow._91_in_dim_separators1395); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal152_tree = (object)adaptor.Create(char_literal152);
					adaptor.AddChild(root_0, char_literal152_tree);
					}

					}
					break;

				default:
					if (cnt41 >= 1)
						goto loop41;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee41 = new EarlyExitException( 41, input );
					DebugRecognitionException(eee41);
					throw eee41;
				}
				cnt41++;
			}
			loop41:
				;

			} finally { DebugExitSubRule(41); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("dim_separators", 36);
			LeaveRule("dim_separators", 36);
			Leave_dim_separators();
			if (state.backtracking > 0) { Memoize(input, 36, dim_separators_StartIndex); }
		}
		DebugLocation(181, 6);
		} finally { DebugExitRule(GrammarFileName, "dim_separators"); }
		return retval;

	}
	// $ANTLR end "dim_separators"

	public class delegate_creation_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_delegate_creation_expression();
	partial void Leave_delegate_creation_expression();

	// $ANTLR start "delegate_creation_expression"
	// cs.g:183:8: public delegate_creation_expression : type_name '(' type_name ')' ;
	[GrammarRule("delegate_creation_expression")]
	public csParser.delegate_creation_expression_return delegate_creation_expression()
	{
		Enter_delegate_creation_expression();
		EnterRule("delegate_creation_expression", 37);
		TraceIn("delegate_creation_expression", 37);
		csParser.delegate_creation_expression_return retval = new csParser.delegate_creation_expression_return();
		retval.Start = (IToken)input.LT(1);
		int delegate_creation_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal154=null;
		IToken char_literal156=null;
		csParser.type_name_return type_name153 = default(csParser.type_name_return);
		csParser.type_name_return type_name155 = default(csParser.type_name_return);

		object char_literal154_tree=null;
		object char_literal156_tree=null;

		try { DebugEnterRule(GrammarFileName, "delegate_creation_expression");
		DebugLocation(183, 35);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 37)) { return retval; }
			// cs.g:183:36: ( type_name '(' type_name ')' )
			DebugEnterAlt(1);
			// cs.g:185:2: type_name '(' type_name ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(185, 2);
			PushFollow(Follow._type_name_in_delegate_creation_expression1410);
			type_name153=type_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name153.Tree);
			DebugLocation(185, 14);
			char_literal154=(IToken)Match(input,90,Follow._90_in_delegate_creation_expression1414); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal154_tree = (object)adaptor.Create(char_literal154);
			adaptor.AddChild(root_0, char_literal154_tree);
			}
			DebugLocation(185, 20);
			PushFollow(Follow._type_name_in_delegate_creation_expression1418);
			type_name155=type_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name155.Tree);
			DebugLocation(185, 32);
			char_literal156=(IToken)Match(input,RPAREN,Follow._RPAREN_in_delegate_creation_expression1422); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal156_tree = (object)adaptor.Create(char_literal156);
			adaptor.AddChild(root_0, char_literal156_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("delegate_creation_expression", 37);
			LeaveRule("delegate_creation_expression", 37);
			Leave_delegate_creation_expression();
			if (state.backtracking > 0) { Memoize(input, 37, delegate_creation_expression_StartIndex); }
		}
		DebugLocation(185, 35);
		} finally { DebugExitRule(GrammarFileName, "delegate_creation_expression"); }
		return retval;

	}
	// $ANTLR end "delegate_creation_expression"

	public class anonymous_object_creation_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_anonymous_object_creation_expression();
	partial void Leave_anonymous_object_creation_expression();

	// $ANTLR start "anonymous_object_creation_expression"
	// cs.g:186:8: public anonymous_object_creation_expression : anonymous_object_initializer ;
	[GrammarRule("anonymous_object_creation_expression")]
	public csParser.anonymous_object_creation_expression_return anonymous_object_creation_expression()
	{
		Enter_anonymous_object_creation_expression();
		EnterRule("anonymous_object_creation_expression", 38);
		TraceIn("anonymous_object_creation_expression", 38);
		csParser.anonymous_object_creation_expression_return retval = new csParser.anonymous_object_creation_expression_return();
		retval.Start = (IToken)input.LT(1);
		int anonymous_object_creation_expression_StartIndex = input.Index;
		object root_0 = null;

		csParser.anonymous_object_initializer_return anonymous_object_initializer157 = default(csParser.anonymous_object_initializer_return);


		try { DebugEnterRule(GrammarFileName, "anonymous_object_creation_expression");
		DebugLocation(186, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 38)) { return retval; }
			// cs.g:186:44: ( anonymous_object_initializer )
			DebugEnterAlt(1);
			// cs.g:188:2: anonymous_object_initializer
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(188, 2);
			PushFollow(Follow._anonymous_object_initializer_in_anonymous_object_creation_expression1435);
			anonymous_object_initializer157=anonymous_object_initializer();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_object_initializer157.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("anonymous_object_creation_expression", 38);
			LeaveRule("anonymous_object_creation_expression", 38);
			Leave_anonymous_object_creation_expression();
			if (state.backtracking > 0) { Memoize(input, 38, anonymous_object_creation_expression_StartIndex); }
		}
		DebugLocation(188, 30);
		} finally { DebugExitRule(GrammarFileName, "anonymous_object_creation_expression"); }
		return retval;

	}
	// $ANTLR end "anonymous_object_creation_expression"

	public class anonymous_object_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_anonymous_object_initializer();
	partial void Leave_anonymous_object_initializer();

	// $ANTLR start "anonymous_object_initializer"
	// cs.g:189:8: public anonymous_object_initializer : '{' ( member_declarator_list ( ',' )? )? '}' ;
	[GrammarRule("anonymous_object_initializer")]
	public csParser.anonymous_object_initializer_return anonymous_object_initializer()
	{
		Enter_anonymous_object_initializer();
		EnterRule("anonymous_object_initializer", 39);
		TraceIn("anonymous_object_initializer", 39);
		csParser.anonymous_object_initializer_return retval = new csParser.anonymous_object_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int anonymous_object_initializer_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal158=null;
		IToken char_literal160=null;
		IToken char_literal161=null;
		csParser.member_declarator_list_return member_declarator_list159 = default(csParser.member_declarator_list_return);

		object char_literal158_tree=null;
		object char_literal160_tree=null;
		object char_literal161_tree=null;

		try { DebugEnterRule(GrammarFileName, "anonymous_object_initializer");
		DebugLocation(189, 45);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 39)) { return retval; }
			// cs.g:189:36: ( '{' ( member_declarator_list ( ',' )? )? '}' )
			DebugEnterAlt(1);
			// cs.g:190:2: '{' ( member_declarator_list ( ',' )? )? '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(190, 2);
			char_literal158=(IToken)Match(input,62,Follow._62_in_anonymous_object_initializer1446); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal158_tree = (object)adaptor.Create(char_literal158);
			adaptor.AddChild(root_0, char_literal158_tree);
			}
			DebugLocation(190, 8);
			// cs.g:190:8: ( member_declarator_list ( ',' )? )?
			int alt43=2;
			try { DebugEnterSubRule(43);
			try { DebugEnterDecision(43, decisionCanBacktrack[43]);
			int LA43_0 = input.LA(1);

			if (((LA43_0>=IDENTIFIER && LA43_0<=NULL)||(LA43_0>=ELIF && LA43_0<=UNDEF)||LA43_0==65||(LA43_0>=132 && LA43_0<=133)||(LA43_0>=135 && LA43_0<=148)||(LA43_0>=150 && LA43_0<=152)||LA43_0==154||(LA43_0>=156 && LA43_0<=168)||LA43_0==170||(LA43_0>=177 && LA43_0<=178)||(LA43_0>=195 && LA43_0<=202)))
			{
				alt43=1;
			}
			} finally { DebugExitDecision(43); }
			switch (alt43)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:190:9: member_declarator_list ( ',' )?
				{
				DebugLocation(190, 9);
				PushFollow(Follow._member_declarator_list_in_anonymous_object_initializer1451);
				member_declarator_list159=member_declarator_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_declarator_list159.Tree);
				DebugLocation(190, 34);
				// cs.g:190:34: ( ',' )?
				int alt42=2;
				try { DebugEnterSubRule(42);
				try { DebugEnterDecision(42, decisionCanBacktrack[42]);
				int LA42_0 = input.LA(1);

				if ((LA42_0==91))
				{
					alt42=1;
				}
				} finally { DebugExitDecision(42); }
				switch (alt42)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:190:34: ','
					{
					DebugLocation(190, 34);
					char_literal160=(IToken)Match(input,91,Follow._91_in_anonymous_object_initializer1455); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal160_tree = (object)adaptor.Create(char_literal160);
					adaptor.AddChild(root_0, char_literal160_tree);
					}

					}
					break;

				}
				} finally { DebugExitSubRule(42); }


				}
				break;

			}
			} finally { DebugExitSubRule(43); }

			DebugLocation(190, 43);
			char_literal161=(IToken)Match(input,63,Follow._63_in_anonymous_object_initializer1462); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal161_tree = (object)adaptor.Create(char_literal161);
			adaptor.AddChild(root_0, char_literal161_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("anonymous_object_initializer", 39);
			LeaveRule("anonymous_object_initializer", 39);
			Leave_anonymous_object_initializer();
			if (state.backtracking > 0) { Memoize(input, 39, anonymous_object_initializer_StartIndex); }
		}
		DebugLocation(190, 45);
		} finally { DebugExitRule(GrammarFileName, "anonymous_object_initializer"); }
		return retval;

	}
	// $ANTLR end "anonymous_object_initializer"

	public class member_declarator_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_member_declarator_list();
	partial void Leave_member_declarator_list();

	// $ANTLR start "member_declarator_list"
	// cs.g:191:8: public member_declarator_list : member_declarator ( ',' member_declarator )* ;
	[GrammarRule("member_declarator_list")]
	public csParser.member_declarator_list_return member_declarator_list()
	{
		Enter_member_declarator_list();
		EnterRule("member_declarator_list", 40);
		TraceIn("member_declarator_list", 40);
		csParser.member_declarator_list_return retval = new csParser.member_declarator_list_return();
		retval.Start = (IToken)input.LT(1);
		int member_declarator_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal163=null;
		csParser.member_declarator_return member_declarator162 = default(csParser.member_declarator_return);
		csParser.member_declarator_return member_declarator164 = default(csParser.member_declarator_return);

		object char_literal163_tree=null;

		try { DebugEnterRule(GrammarFileName, "member_declarator_list");
		DebugLocation(191, 45);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 40)) { return retval; }
			// cs.g:191:30: ( member_declarator ( ',' member_declarator )* )
			DebugEnterAlt(1);
			// cs.g:192:2: member_declarator ( ',' member_declarator )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(192, 2);
			PushFollow(Follow._member_declarator_in_member_declarator_list1472);
			member_declarator162=member_declarator();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_declarator162.Tree);
			DebugLocation(192, 21);
			// cs.g:192:21: ( ',' member_declarator )*
			try { DebugEnterSubRule(44);
			while (true)
			{
				int alt44=2;
				try { DebugEnterDecision(44, decisionCanBacktrack[44]);
				int LA44_0 = input.LA(1);

				if ((LA44_0==91))
				{
					int LA44_1 = input.LA(2);

					if (((LA44_1>=IDENTIFIER && LA44_1<=NULL)||(LA44_1>=ELIF && LA44_1<=UNDEF)||LA44_1==65||(LA44_1>=132 && LA44_1<=133)||(LA44_1>=135 && LA44_1<=148)||(LA44_1>=150 && LA44_1<=152)||LA44_1==154||(LA44_1>=156 && LA44_1<=168)||LA44_1==170||(LA44_1>=177 && LA44_1<=178)||(LA44_1>=195 && LA44_1<=202)))
					{
						alt44=1;
					}


				}


				} finally { DebugExitDecision(44); }
				switch ( alt44 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:192:22: ',' member_declarator
					{
					DebugLocation(192, 22);
					char_literal163=(IToken)Match(input,91,Follow._91_in_member_declarator_list1476); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal163_tree = (object)adaptor.Create(char_literal163);
					adaptor.AddChild(root_0, char_literal163_tree);
					}
					DebugLocation(192, 26);
					PushFollow(Follow._member_declarator_in_member_declarator_list1478);
					member_declarator164=member_declarator();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_declarator164.Tree);

					}
					break;

				default:
					goto loop44;
				}
			}

			loop44:
				;

			} finally { DebugExitSubRule(44); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("member_declarator_list", 40);
			LeaveRule("member_declarator_list", 40);
			Leave_member_declarator_list();
			if (state.backtracking > 0) { Memoize(input, 40, member_declarator_list_StartIndex); }
		}
		DebugLocation(192, 45);
		} finally { DebugExitRule(GrammarFileName, "member_declarator_list"); }
		return retval;

	}
	// $ANTLR end "member_declarator_list"

	public class member_declarator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_member_declarator();
	partial void Leave_member_declarator();

	// $ANTLR start "member_declarator"
	// cs.g:193:8: public member_declarator : qid ( '=' expression )? ;
	[GrammarRule("member_declarator")]
	public csParser.member_declarator_return member_declarator()
	{
		Enter_member_declarator();
		EnterRule("member_declarator", 41);
		TraceIn("member_declarator", 41);
		csParser.member_declarator_return retval = new csParser.member_declarator_return();
		retval.Start = (IToken)input.LT(1);
		int member_declarator_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal166=null;
		csParser.qid_return qid165 = default(csParser.qid_return);
		csParser.expression_return expression167 = default(csParser.expression_return);

		object char_literal166_tree=null;

		try { DebugEnterRule(GrammarFileName, "member_declarator");
		DebugLocation(193, 27);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 41)) { return retval; }
			// cs.g:193:25: ( qid ( '=' expression )? )
			DebugEnterAlt(1);
			// cs.g:194:2: qid ( '=' expression )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(194, 2);
			PushFollow(Follow._qid_in_member_declarator1492);
			qid165=qid();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, qid165.Tree);
			DebugLocation(194, 8);
			// cs.g:194:8: ( '=' expression )?
			int alt45=2;
			try { DebugEnterSubRule(45);
			try { DebugEnterDecision(45, decisionCanBacktrack[45]);
			int LA45_0 = input.LA(1);

			if ((LA45_0==66))
			{
				alt45=1;
			}
			} finally { DebugExitDecision(45); }
			switch (alt45)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:194:9: '=' expression
				{
				DebugLocation(194, 9);
				char_literal166=(IToken)Match(input,66,Follow._66_in_member_declarator1497); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal166_tree = (object)adaptor.Create(char_literal166);
				adaptor.AddChild(root_0, char_literal166_tree);
				}
				DebugLocation(194, 15);
				PushFollow(Follow._expression_in_member_declarator1501);
				expression167=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression167.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(45); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("member_declarator", 41);
			LeaveRule("member_declarator", 41);
			Leave_member_declarator();
			if (state.backtracking > 0) { Memoize(input, 41, member_declarator_StartIndex); }
		}
		DebugLocation(194, 27);
		} finally { DebugExitRule(GrammarFileName, "member_declarator"); }
		return retval;

	}
	// $ANTLR end "member_declarator"

	public class primary_or_array_creation_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_primary_or_array_creation_expression();
	partial void Leave_primary_or_array_creation_expression();

	// $ANTLR start "primary_or_array_creation_expression"
	// cs.g:195:8: public primary_or_array_creation_expression : ( ( array_creation_expression )=> array_creation_expression | primary_expression );
	[GrammarRule("primary_or_array_creation_expression")]
	public csParser.primary_or_array_creation_expression_return primary_or_array_creation_expression()
	{
		Enter_primary_or_array_creation_expression();
		EnterRule("primary_or_array_creation_expression", 42);
		TraceIn("primary_or_array_creation_expression", 42);
		csParser.primary_or_array_creation_expression_return retval = new csParser.primary_or_array_creation_expression_return();
		retval.Start = (IToken)input.LT(1);
		int primary_or_array_creation_expression_StartIndex = input.Index;
		object root_0 = null;

		csParser.array_creation_expression_return array_creation_expression168 = default(csParser.array_creation_expression_return);
		csParser.primary_expression_return primary_expression169 = default(csParser.primary_expression_return);


		try { DebugEnterRule(GrammarFileName, "primary_or_array_creation_expression");
		DebugLocation(195, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 42)) { return retval; }
			// cs.g:195:44: ( ( array_creation_expression )=> array_creation_expression | primary_expression )
			int alt46=2;
			try { DebugEnterDecision(46, decisionCanBacktrack[46]);
			try
			{
				alt46 = dfa46.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(46); }
			switch (alt46)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:196:2: ( array_creation_expression )=> array_creation_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(196, 33);
				PushFollow(Follow._array_creation_expression_in_primary_or_array_creation_expression1519);
				array_creation_expression168=array_creation_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_creation_expression168.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:197:4: primary_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(197, 4);
				PushFollow(Follow._primary_expression_in_primary_or_array_creation_expression1524);
				primary_expression169=primary_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression169.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("primary_or_array_creation_expression", 42);
			LeaveRule("primary_or_array_creation_expression", 42);
			Leave_primary_or_array_creation_expression();
			if (state.backtracking > 0) { Memoize(input, 42, primary_or_array_creation_expression_StartIndex); }
		}
		DebugLocation(198, 1);
		} finally { DebugExitRule(GrammarFileName, "primary_or_array_creation_expression"); }
		return retval;

	}
	// $ANTLR end "primary_or_array_creation_expression"

	public class array_creation_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_array_creation_expression();
	partial void Leave_array_creation_expression();

	// $ANTLR start "array_creation_expression"
	// cs.g:200:8: public array_creation_expression : 'new' ( type ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer ) | rank_specifier ( array_initializer ) ) ;
	[GrammarRule("array_creation_expression")]
	public csParser.array_creation_expression_return array_creation_expression()
	{
		Enter_array_creation_expression();
		EnterRule("array_creation_expression", 43);
		TraceIn("array_creation_expression", 43);
		csParser.array_creation_expression_return retval = new csParser.array_creation_expression_return();
		retval.Start = (IToken)input.LT(1);
		int array_creation_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal170=null;
		IToken char_literal172=null;
		IToken char_literal174=null;
		csParser.type_return type171 = default(csParser.type_return);
		csParser.expression_list_return expression_list173 = default(csParser.expression_list_return);
		csParser.rank_specifiers_return rank_specifiers175 = default(csParser.rank_specifiers_return);
		csParser.array_initializer_return array_initializer176 = default(csParser.array_initializer_return);
		csParser.arguments_return arguments177 = default(csParser.arguments_return);
		csParser.invocation_part_return invocation_part178 = default(csParser.invocation_part_return);
		csParser.invocation_part_return invocation_part179 = default(csParser.invocation_part_return);
		csParser.arguments_return arguments180 = default(csParser.arguments_return);
		csParser.array_initializer_return array_initializer181 = default(csParser.array_initializer_return);
		csParser.rank_specifier_return rank_specifier182 = default(csParser.rank_specifier_return);
		csParser.array_initializer_return array_initializer183 = default(csParser.array_initializer_return);

		object string_literal170_tree=null;
		object char_literal172_tree=null;
		object char_literal174_tree=null;

		try { DebugEnterRule(GrammarFileName, "array_creation_expression");
		DebugLocation(200, 4);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 43)) { return retval; }
			// cs.g:200:33: ( 'new' ( type ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer ) | rank_specifier ( array_initializer ) ) )
			DebugEnterAlt(1);
			// cs.g:201:2: 'new' ( type ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer ) | rank_specifier ( array_initializer ) )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(201, 2);
			string_literal170=(IToken)Match(input,68,Follow._68_in_array_creation_expression1537); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal170_tree = (object)adaptor.Create(string_literal170);
			adaptor.AddChild(root_0, string_literal170_tree);
			}
			DebugLocation(202, 3);
			// cs.g:202:3: ( type ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer ) | rank_specifier ( array_initializer ) )
			int alt52=2;
			try { DebugEnterSubRule(52);
			try { DebugEnterDecision(52, decisionCanBacktrack[52]);
			int LA52_0 = input.LA(1);

			if ((LA52_0==IDENTIFIER||(LA52_0>=ELIF && LA52_0<=UNDEF)||LA52_0==65||LA52_0==82||(LA52_0>=132 && LA52_0<=133)||(LA52_0>=135 && LA52_0<=148)||(LA52_0>=150 && LA52_0<=152)||LA52_0==154||(LA52_0>=156 && LA52_0<=168)||LA52_0==170||(LA52_0>=177 && LA52_0<=178)||(LA52_0>=195 && LA52_0<=202)))
			{
				alt52=1;
			}
			else if ((LA52_0==88))
			{
				alt52=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 52, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(52); }
			switch (alt52)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:202:4: type ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer )
				{
				DebugLocation(202, 4);
				PushFollow(Follow._type_in_array_creation_expression1545);
				type171=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type171.Tree);
				DebugLocation(202, 11);
				// cs.g:202:11: ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer )
				int alt51=2;
				try { DebugEnterSubRule(51);
				try { DebugEnterDecision(51, decisionCanBacktrack[51]);
				int LA51_0 = input.LA(1);

				if ((LA51_0==88))
				{
					alt51=1;
				}
				else if ((LA51_0==62))
				{
					alt51=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 51, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				} finally { DebugExitDecision(51); }
				switch (alt51)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:202:12: '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments )
					{
					DebugLocation(202, 12);
					char_literal172=(IToken)Match(input,88,Follow._88_in_array_creation_expression1550); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal172_tree = (object)adaptor.Create(char_literal172);
					adaptor.AddChild(root_0, char_literal172_tree);
					}
					DebugLocation(202, 18);
					PushFollow(Follow._expression_list_in_array_creation_expression1554);
					expression_list173=expression_list();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression_list173.Tree);
					DebugLocation(202, 36);
					char_literal174=(IToken)Match(input,89,Follow._89_in_array_creation_expression1558); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal174_tree = (object)adaptor.Create(char_literal174);
					adaptor.AddChild(root_0, char_literal174_tree);
					}
					DebugLocation(203, 6);
					// cs.g:203:6: ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments )
					int alt50=2;
					try { DebugEnterSubRule(50);
					try { DebugEnterDecision(50, decisionCanBacktrack[50]);
					try
					{
						alt50 = dfa50.Predict(input);
					}
					catch (NoViableAltException nvae)
					{
						DebugRecognitionException(nvae);
						throw;
					}
					} finally { DebugExitDecision(50); }
					switch (alt50)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:203:8: ( rank_specifiers )? ( array_initializer )?
						{
						DebugLocation(203, 8);
						// cs.g:203:8: ( rank_specifiers )?
						int alt47=2;
						try { DebugEnterSubRule(47);
						try { DebugEnterDecision(47, decisionCanBacktrack[47]);
						int LA47_0 = input.LA(1);

						if ((LA47_0==88))
						{
							alt47=1;
						}
						} finally { DebugExitDecision(47); }
						switch (alt47)
						{
						case 1:
							DebugEnterAlt(1);
							// cs.g:203:8: rank_specifiers
							{
							DebugLocation(203, 8);
							PushFollow(Follow._rank_specifiers_in_array_creation_expression1570);
							rank_specifiers175=rank_specifiers();
							PopFollow();
							if (state.failed) return retval;
							if ( state.backtracking == 0 ) adaptor.AddChild(root_0, rank_specifiers175.Tree);

							}
							break;

						}
						} finally { DebugExitSubRule(47); }

						DebugLocation(203, 27);
						// cs.g:203:27: ( array_initializer )?
						int alt48=2;
						try { DebugEnterSubRule(48);
						try { DebugEnterDecision(48, decisionCanBacktrack[48]);
						int LA48_0 = input.LA(1);

						if ((LA48_0==62))
						{
							alt48=1;
						}
						} finally { DebugExitDecision(48); }
						switch (alt48)
						{
						case 1:
							DebugEnterAlt(1);
							// cs.g:203:27: array_initializer
							{
							DebugLocation(203, 27);
							PushFollow(Follow._array_initializer_in_array_creation_expression1575);
							array_initializer176=array_initializer();
							PopFollow();
							if (state.failed) return retval;
							if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_initializer176.Tree);

							}
							break;

						}
						} finally { DebugExitSubRule(48); }


						}
						break;
					case 2:
						DebugEnterAlt(2);
						// cs.g:205:8: ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments
						{
						DebugLocation(205, 8);
						// cs.g:205:8: ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )*
						try { DebugEnterSubRule(49);
						while (true)
						{
							int alt49=3;
							try { DebugEnterDecision(49, decisionCanBacktrack[49]);
							int LA49_0 = input.LA(1);

							if ((LA49_0==90))
							{
								int LA49_1 = input.LA(2);

								if ((EvaluatePredicate(synpred12_cs_fragment)))
								{
									alt49=1;
								}


							}
							else if (((LA49_0>=DOT && LA49_0<=PTR)||LA49_0==88))
							{
								alt49=2;
							}


							} finally { DebugExitDecision(49); }
							switch ( alt49 )
							{
							case 1:
								DebugEnterAlt(1);
								// cs.g:205:10: ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part )
								{
								DebugLocation(205, 10);
								// cs.g:205:10: ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part )
								DebugEnterAlt(1);
								// cs.g:205:11: ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part
								{
								DebugLocation(205, 43);
								PushFollow(Follow._arguments_in_array_creation_expression1611);
								arguments177=arguments();
								PopFollow();
								if (state.failed) return retval;
								if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments177.Tree);
								DebugLocation(205, 55);
								PushFollow(Follow._invocation_part_in_array_creation_expression1615);
								invocation_part178=invocation_part();
								PopFollow();
								if (state.failed) return retval;
								if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_part178.Tree);

								}


								}
								break;
							case 2:
								DebugEnterAlt(2);
								// cs.g:206:10: invocation_part
								{
								DebugLocation(206, 10);
								PushFollow(Follow._invocation_part_in_array_creation_expression1627);
								invocation_part179=invocation_part();
								PopFollow();
								if (state.failed) return retval;
								if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_part179.Tree);

								}
								break;

							default:
								goto loop49;
							}
						}

						loop49:
							;

						} finally { DebugExitSubRule(49); }

						DebugLocation(206, 30);
						PushFollow(Follow._arguments_in_array_creation_expression1633);
						arguments180=arguments();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments180.Tree);

						}
						break;

					}
					} finally { DebugExitSubRule(50); }


					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:208:7: array_initializer
					{
					DebugLocation(208, 7);
					PushFollow(Follow._array_initializer_in_array_creation_expression1655);
					array_initializer181=array_initializer();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_initializer181.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(51); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:210:5: rank_specifier ( array_initializer )
				{
				DebugLocation(210, 5);
				PushFollow(Follow._rank_specifier_in_array_creation_expression1669);
				rank_specifier182=rank_specifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, rank_specifier182.Tree);
				DebugLocation(211, 4);
				// cs.g:211:4: ( array_initializer )
				DebugEnterAlt(1);
				// cs.g:211:5: array_initializer
				{
				DebugLocation(211, 5);
				PushFollow(Follow._array_initializer_in_array_creation_expression1678);
				array_initializer183=array_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_initializer183.Tree);

				}


				}
				break;

			}
			} finally { DebugExitSubRule(52); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("array_creation_expression", 43);
			LeaveRule("array_creation_expression", 43);
			Leave_array_creation_expression();
			if (state.backtracking > 0) { Memoize(input, 43, array_creation_expression_StartIndex); }
		}
		DebugLocation(213, 4);
		} finally { DebugExitRule(GrammarFileName, "array_creation_expression"); }
		return retval;

	}
	// $ANTLR end "array_creation_expression"

	public class array_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_array_initializer();
	partial void Leave_array_initializer();

	// $ANTLR start "array_initializer"
	// cs.g:214:8: public array_initializer : '{' ( variable_initializer_list )? ( ',' )? '}' ;
	[GrammarRule("array_initializer")]
	public csParser.array_initializer_return array_initializer()
	{
		Enter_array_initializer();
		EnterRule("array_initializer", 44);
		TraceIn("array_initializer", 44);
		csParser.array_initializer_return retval = new csParser.array_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int array_initializer_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal184=null;
		IToken char_literal186=null;
		IToken char_literal187=null;
		csParser.variable_initializer_list_return variable_initializer_list185 = default(csParser.variable_initializer_list_return);

		object char_literal184_tree=null;
		object char_literal186_tree=null;
		object char_literal187_tree=null;

		try { DebugEnterRule(GrammarFileName, "array_initializer");
		DebugLocation(214, 47);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 44)) { return retval; }
			// cs.g:214:25: ( '{' ( variable_initializer_list )? ( ',' )? '}' )
			DebugEnterAlt(1);
			// cs.g:215:2: '{' ( variable_initializer_list )? ( ',' )? '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(215, 2);
			char_literal184=(IToken)Match(input,62,Follow._62_in_array_initializer1701); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal184_tree = (object)adaptor.Create(char_literal184);
			adaptor.AddChild(root_0, char_literal184_tree);
			}
			DebugLocation(215, 8);
			// cs.g:215:8: ( variable_initializer_list )?
			int alt53=2;
			try { DebugEnterSubRule(53);
			try { DebugEnterDecision(53, decisionCanBacktrack[53]);
			int LA53_0 = input.LA(1);

			if (((LA53_0>=IDENTIFIER && LA53_0<=NULL)||LA53_0==MINUS||(LA53_0>=ELIF && LA53_0<=UNDEF)||LA53_0==62||LA53_0==65||LA53_0==68||(LA53_0>=83 && LA53_0<=84)||(LA53_0>=86 && LA53_0<=87)||LA53_0==90||(LA53_0>=95 && LA53_0<=100)||LA53_0==102||(LA53_0>=104 && LA53_0<=106)||LA53_0==117||(LA53_0>=132 && LA53_0<=133)||(LA53_0>=135 && LA53_0<=148)||(LA53_0>=150 && LA53_0<=152)||LA53_0==154||(LA53_0>=156 && LA53_0<=168)||LA53_0==170||(LA53_0>=177 && LA53_0<=178)||(LA53_0>=195 && LA53_0<=202)))
			{
				alt53=1;
			}
			} finally { DebugExitDecision(53); }
			switch (alt53)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:215:8: variable_initializer_list
				{
				DebugLocation(215, 8);
				PushFollow(Follow._variable_initializer_list_in_array_initializer1705);
				variable_initializer_list185=variable_initializer_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_initializer_list185.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(53); }

			DebugLocation(215, 37);
			// cs.g:215:37: ( ',' )?
			int alt54=2;
			try { DebugEnterSubRule(54);
			try { DebugEnterDecision(54, decisionCanBacktrack[54]);
			int LA54_0 = input.LA(1);

			if ((LA54_0==91))
			{
				alt54=1;
			}
			} finally { DebugExitDecision(54); }
			switch (alt54)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:215:37: ','
				{
				DebugLocation(215, 37);
				char_literal186=(IToken)Match(input,91,Follow._91_in_array_initializer1710); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal186_tree = (object)adaptor.Create(char_literal186);
				adaptor.AddChild(root_0, char_literal186_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(54); }

			DebugLocation(215, 44);
			char_literal187=(IToken)Match(input,63,Follow._63_in_array_initializer1715); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal187_tree = (object)adaptor.Create(char_literal187);
			adaptor.AddChild(root_0, char_literal187_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("array_initializer", 44);
			LeaveRule("array_initializer", 44);
			Leave_array_initializer();
			if (state.backtracking > 0) { Memoize(input, 44, array_initializer_StartIndex); }
		}
		DebugLocation(215, 47);
		} finally { DebugExitRule(GrammarFileName, "array_initializer"); }
		return retval;

	}
	// $ANTLR end "array_initializer"

	public class variable_initializer_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_variable_initializer_list();
	partial void Leave_variable_initializer_list();

	// $ANTLR start "variable_initializer_list"
	// cs.g:216:8: public variable_initializer_list : variable_initializer ( ',' variable_initializer )* ;
	[GrammarRule("variable_initializer_list")]
	public csParser.variable_initializer_list_return variable_initializer_list()
	{
		Enter_variable_initializer_list();
		EnterRule("variable_initializer_list", 45);
		TraceIn("variable_initializer_list", 45);
		csParser.variable_initializer_list_return retval = new csParser.variable_initializer_list_return();
		retval.Start = (IToken)input.LT(1);
		int variable_initializer_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal189=null;
		csParser.variable_initializer_return variable_initializer188 = default(csParser.variable_initializer_return);
		csParser.variable_initializer_return variable_initializer190 = default(csParser.variable_initializer_return);

		object char_literal189_tree=null;

		try { DebugEnterRule(GrammarFileName, "variable_initializer_list");
		DebugLocation(216, 50);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 45)) { return retval; }
			// cs.g:216:33: ( variable_initializer ( ',' variable_initializer )* )
			DebugEnterAlt(1);
			// cs.g:217:2: variable_initializer ( ',' variable_initializer )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(217, 2);
			PushFollow(Follow._variable_initializer_in_variable_initializer_list1725);
			variable_initializer188=variable_initializer();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_initializer188.Tree);
			DebugLocation(217, 23);
			// cs.g:217:23: ( ',' variable_initializer )*
			try { DebugEnterSubRule(55);
			while (true)
			{
				int alt55=2;
				try { DebugEnterDecision(55, decisionCanBacktrack[55]);
				int LA55_0 = input.LA(1);

				if ((LA55_0==91))
				{
					int LA55_1 = input.LA(2);

					if (((LA55_1>=IDENTIFIER && LA55_1<=NULL)||LA55_1==MINUS||(LA55_1>=ELIF && LA55_1<=UNDEF)||LA55_1==62||LA55_1==65||LA55_1==68||(LA55_1>=83 && LA55_1<=84)||(LA55_1>=86 && LA55_1<=87)||LA55_1==90||(LA55_1>=95 && LA55_1<=100)||LA55_1==102||(LA55_1>=104 && LA55_1<=106)||LA55_1==117||(LA55_1>=132 && LA55_1<=133)||(LA55_1>=135 && LA55_1<=148)||(LA55_1>=150 && LA55_1<=152)||LA55_1==154||(LA55_1>=156 && LA55_1<=168)||LA55_1==170||(LA55_1>=177 && LA55_1<=178)||(LA55_1>=195 && LA55_1<=202)))
					{
						alt55=1;
					}


				}


				} finally { DebugExitDecision(55); }
				switch ( alt55 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:217:24: ',' variable_initializer
					{
					DebugLocation(217, 24);
					char_literal189=(IToken)Match(input,91,Follow._91_in_variable_initializer_list1728); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal189_tree = (object)adaptor.Create(char_literal189);
					adaptor.AddChild(root_0, char_literal189_tree);
					}
					DebugLocation(217, 28);
					PushFollow(Follow._variable_initializer_in_variable_initializer_list1730);
					variable_initializer190=variable_initializer();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_initializer190.Tree);

					}
					break;

				default:
					goto loop55;
				}
			}

			loop55:
				;

			} finally { DebugExitSubRule(55); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("variable_initializer_list", 45);
			LeaveRule("variable_initializer_list", 45);
			Leave_variable_initializer_list();
			if (state.backtracking > 0) { Memoize(input, 45, variable_initializer_list_StartIndex); }
		}
		DebugLocation(217, 50);
		} finally { DebugExitRule(GrammarFileName, "variable_initializer_list"); }
		return retval;

	}
	// $ANTLR end "variable_initializer_list"

	public class variable_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_variable_initializer();
	partial void Leave_variable_initializer();

	// $ANTLR start "variable_initializer"
	// cs.g:218:8: public variable_initializer : ( expression | array_initializer );
	[GrammarRule("variable_initializer")]
	public csParser.variable_initializer_return variable_initializer()
	{
		Enter_variable_initializer();
		EnterRule("variable_initializer", 46);
		TraceIn("variable_initializer", 46);
		csParser.variable_initializer_return retval = new csParser.variable_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int variable_initializer_StartIndex = input.Index;
		object root_0 = null;

		csParser.expression_return expression191 = default(csParser.expression_return);
		csParser.array_initializer_return array_initializer192 = default(csParser.array_initializer_return);


		try { DebugEnterRule(GrammarFileName, "variable_initializer");
		DebugLocation(218, 32);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 46)) { return retval; }
			// cs.g:218:28: ( expression | array_initializer )
			int alt56=2;
			try { DebugEnterDecision(56, decisionCanBacktrack[56]);
			int LA56_0 = input.LA(1);

			if (((LA56_0>=IDENTIFIER && LA56_0<=NULL)||LA56_0==MINUS||(LA56_0>=ELIF && LA56_0<=UNDEF)||LA56_0==65||LA56_0==68||(LA56_0>=83 && LA56_0<=84)||(LA56_0>=86 && LA56_0<=87)||LA56_0==90||(LA56_0>=95 && LA56_0<=100)||LA56_0==102||(LA56_0>=104 && LA56_0<=106)||LA56_0==117||(LA56_0>=132 && LA56_0<=133)||(LA56_0>=135 && LA56_0<=148)||(LA56_0>=150 && LA56_0<=152)||LA56_0==154||(LA56_0>=156 && LA56_0<=168)||LA56_0==170||(LA56_0>=177 && LA56_0<=178)||(LA56_0>=195 && LA56_0<=202)))
			{
				alt56=1;
			}
			else if ((LA56_0==62))
			{
				alt56=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 56, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(56); }
			switch (alt56)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:219:2: expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(219, 2);
				PushFollow(Follow._expression_in_variable_initializer1742);
				expression191=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression191.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:219:15: array_initializer
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(219, 15);
				PushFollow(Follow._array_initializer_in_variable_initializer1746);
				array_initializer192=array_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_initializer192.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("variable_initializer", 46);
			LeaveRule("variable_initializer", 46);
			Leave_variable_initializer();
			if (state.backtracking > 0) { Memoize(input, 46, variable_initializer_StartIndex); }
		}
		DebugLocation(219, 32);
		} finally { DebugExitRule(GrammarFileName, "variable_initializer"); }
		return retval;

	}
	// $ANTLR end "variable_initializer"

	public class sizeof_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_sizeof_expression();
	partial void Leave_sizeof_expression();

	// $ANTLR start "sizeof_expression"
	// cs.g:220:8: public sizeof_expression : 'sizeof' '(' unmanaged_type ')' ;
	[GrammarRule("sizeof_expression")]
	public csParser.sizeof_expression_return sizeof_expression()
	{
		Enter_sizeof_expression();
		EnterRule("sizeof_expression", 47);
		TraceIn("sizeof_expression", 47);
		csParser.sizeof_expression_return retval = new csParser.sizeof_expression_return();
		retval.Start = (IToken)input.LT(1);
		int sizeof_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal193=null;
		IToken char_literal194=null;
		IToken char_literal196=null;
		csParser.unmanaged_type_return unmanaged_type195 = default(csParser.unmanaged_type_return);

		object string_literal193_tree=null;
		object char_literal194_tree=null;
		object char_literal196_tree=null;

		try { DebugEnterRule(GrammarFileName, "sizeof_expression");
		DebugLocation(220, 38);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 47)) { return retval; }
			// cs.g:220:25: ( 'sizeof' '(' unmanaged_type ')' )
			DebugEnterAlt(1);
			// cs.g:221:2: 'sizeof' '(' unmanaged_type ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(221, 2);
			string_literal193=(IToken)Match(input,95,Follow._95_in_sizeof_expression1756); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal193_tree = (object)adaptor.Create(string_literal193);
			adaptor.AddChild(root_0, string_literal193_tree);
			}
			DebugLocation(221, 13);
			char_literal194=(IToken)Match(input,90,Follow._90_in_sizeof_expression1760); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal194_tree = (object)adaptor.Create(char_literal194);
			adaptor.AddChild(root_0, char_literal194_tree);
			}
			DebugLocation(221, 19);
			PushFollow(Follow._unmanaged_type_in_sizeof_expression1764);
			unmanaged_type195=unmanaged_type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unmanaged_type195.Tree);
			DebugLocation(221, 36);
			char_literal196=(IToken)Match(input,RPAREN,Follow._RPAREN_in_sizeof_expression1768); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal196_tree = (object)adaptor.Create(char_literal196);
			adaptor.AddChild(root_0, char_literal196_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("sizeof_expression", 47);
			LeaveRule("sizeof_expression", 47);
			Leave_sizeof_expression();
			if (state.backtracking > 0) { Memoize(input, 47, sizeof_expression_StartIndex); }
		}
		DebugLocation(221, 38);
		} finally { DebugExitRule(GrammarFileName, "sizeof_expression"); }
		return retval;

	}
	// $ANTLR end "sizeof_expression"

	public class checked_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_checked_expression();
	partial void Leave_checked_expression();

	// $ANTLR start "checked_expression"
	// cs.g:222:8: public checked_expression : 'checked' '(' expression ')' ;
	[GrammarRule("checked_expression")]
	public csParser.checked_expression_return checked_expression()
	{
		Enter_checked_expression();
		EnterRule("checked_expression", 48);
		TraceIn("checked_expression", 48);
		csParser.checked_expression_return retval = new csParser.checked_expression_return();
		retval.Start = (IToken)input.LT(1);
		int checked_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal197=null;
		IToken char_literal198=null;
		IToken char_literal200=null;
		csParser.expression_return expression199 = default(csParser.expression_return);

		object string_literal197_tree=null;
		object char_literal198_tree=null;
		object char_literal200_tree=null;

		try { DebugEnterRule(GrammarFileName, "checked_expression");
		DebugLocation(222, 36);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 48)) { return retval; }
			// cs.g:222:26: ( 'checked' '(' expression ')' )
			DebugEnterAlt(1);
			// cs.g:223:2: 'checked' '(' expression ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(223, 2);
			string_literal197=(IToken)Match(input,96,Follow._96_in_checked_expression1778); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal197_tree = (object)adaptor.Create(string_literal197);
			adaptor.AddChild(root_0, string_literal197_tree);
			}
			DebugLocation(223, 14);
			char_literal198=(IToken)Match(input,90,Follow._90_in_checked_expression1782); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal198_tree = (object)adaptor.Create(char_literal198);
			adaptor.AddChild(root_0, char_literal198_tree);
			}
			DebugLocation(223, 20);
			PushFollow(Follow._expression_in_checked_expression1786);
			expression199=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression199.Tree);
			DebugLocation(223, 33);
			char_literal200=(IToken)Match(input,RPAREN,Follow._RPAREN_in_checked_expression1790); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal200_tree = (object)adaptor.Create(char_literal200);
			adaptor.AddChild(root_0, char_literal200_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("checked_expression", 48);
			LeaveRule("checked_expression", 48);
			Leave_checked_expression();
			if (state.backtracking > 0) { Memoize(input, 48, checked_expression_StartIndex); }
		}
		DebugLocation(223, 36);
		} finally { DebugExitRule(GrammarFileName, "checked_expression"); }
		return retval;

	}
	// $ANTLR end "checked_expression"

	public class unchecked_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_unchecked_expression();
	partial void Leave_unchecked_expression();

	// $ANTLR start "unchecked_expression"
	// cs.g:224:8: public unchecked_expression : 'unchecked' '(' expression ')' ;
	[GrammarRule("unchecked_expression")]
	public csParser.unchecked_expression_return unchecked_expression()
	{
		Enter_unchecked_expression();
		EnterRule("unchecked_expression", 49);
		TraceIn("unchecked_expression", 49);
		csParser.unchecked_expression_return retval = new csParser.unchecked_expression_return();
		retval.Start = (IToken)input.LT(1);
		int unchecked_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal201=null;
		IToken char_literal202=null;
		IToken char_literal204=null;
		csParser.expression_return expression203 = default(csParser.expression_return);

		object string_literal201_tree=null;
		object char_literal202_tree=null;
		object char_literal204_tree=null;

		try { DebugEnterRule(GrammarFileName, "unchecked_expression");
		DebugLocation(224, 38);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 49)) { return retval; }
			// cs.g:224:28: ( 'unchecked' '(' expression ')' )
			DebugEnterAlt(1);
			// cs.g:225:2: 'unchecked' '(' expression ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(225, 2);
			string_literal201=(IToken)Match(input,97,Follow._97_in_unchecked_expression1801); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal201_tree = (object)adaptor.Create(string_literal201);
			adaptor.AddChild(root_0, string_literal201_tree);
			}
			DebugLocation(225, 16);
			char_literal202=(IToken)Match(input,90,Follow._90_in_unchecked_expression1805); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal202_tree = (object)adaptor.Create(char_literal202);
			adaptor.AddChild(root_0, char_literal202_tree);
			}
			DebugLocation(225, 22);
			PushFollow(Follow._expression_in_unchecked_expression1809);
			expression203=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression203.Tree);
			DebugLocation(225, 35);
			char_literal204=(IToken)Match(input,RPAREN,Follow._RPAREN_in_unchecked_expression1813); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal204_tree = (object)adaptor.Create(char_literal204);
			adaptor.AddChild(root_0, char_literal204_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("unchecked_expression", 49);
			LeaveRule("unchecked_expression", 49);
			Leave_unchecked_expression();
			if (state.backtracking > 0) { Memoize(input, 49, unchecked_expression_StartIndex); }
		}
		DebugLocation(225, 38);
		} finally { DebugExitRule(GrammarFileName, "unchecked_expression"); }
		return retval;

	}
	// $ANTLR end "unchecked_expression"

	public class default_value_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_default_value_expression();
	partial void Leave_default_value_expression();

	// $ANTLR start "default_value_expression"
	// cs.g:226:8: public default_value_expression : 'default' '(' type ')' ;
	[GrammarRule("default_value_expression")]
	public csParser.default_value_expression_return default_value_expression()
	{
		Enter_default_value_expression();
		EnterRule("default_value_expression", 50);
		TraceIn("default_value_expression", 50);
		csParser.default_value_expression_return retval = new csParser.default_value_expression_return();
		retval.Start = (IToken)input.LT(1);
		int default_value_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal205=null;
		IToken char_literal206=null;
		IToken char_literal208=null;
		csParser.type_return type207 = default(csParser.type_return);

		object string_literal205_tree=null;
		object char_literal206_tree=null;
		object char_literal208_tree=null;

		try { DebugEnterRule(GrammarFileName, "default_value_expression");
		DebugLocation(226, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 50)) { return retval; }
			// cs.g:226:32: ( 'default' '(' type ')' )
			DebugEnterAlt(1);
			// cs.g:227:2: 'default' '(' type ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(227, 2);
			string_literal205=(IToken)Match(input,98,Follow._98_in_default_value_expression1824); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal205_tree = (object)adaptor.Create(string_literal205);
			adaptor.AddChild(root_0, string_literal205_tree);
			}
			DebugLocation(227, 14);
			char_literal206=(IToken)Match(input,90,Follow._90_in_default_value_expression1828); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal206_tree = (object)adaptor.Create(char_literal206);
			adaptor.AddChild(root_0, char_literal206_tree);
			}
			DebugLocation(227, 20);
			PushFollow(Follow._type_in_default_value_expression1832);
			type207=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type207.Tree);
			DebugLocation(227, 27);
			char_literal208=(IToken)Match(input,RPAREN,Follow._RPAREN_in_default_value_expression1836); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal208_tree = (object)adaptor.Create(char_literal208);
			adaptor.AddChild(root_0, char_literal208_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("default_value_expression", 50);
			LeaveRule("default_value_expression", 50);
			Leave_default_value_expression();
			if (state.backtracking > 0) { Memoize(input, 50, default_value_expression_StartIndex); }
		}
		DebugLocation(227, 30);
		} finally { DebugExitRule(GrammarFileName, "default_value_expression"); }
		return retval;

	}
	// $ANTLR end "default_value_expression"

	public class anonymous_method_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_anonymous_method_expression();
	partial void Leave_anonymous_method_expression();

	// $ANTLR start "anonymous_method_expression"
	// cs.g:228:8: public anonymous_method_expression : 'delegate' ( explicit_anonymous_function_signature )? block ;
	[GrammarRule("anonymous_method_expression")]
	public csParser.anonymous_method_expression_return anonymous_method_expression()
	{
		Enter_anonymous_method_expression();
		EnterRule("anonymous_method_expression", 51);
		TraceIn("anonymous_method_expression", 51);
		csParser.anonymous_method_expression_return retval = new csParser.anonymous_method_expression_return();
		retval.Start = (IToken)input.LT(1);
		int anonymous_method_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal209=null;
		csParser.explicit_anonymous_function_signature_return explicit_anonymous_function_signature210 = default(csParser.explicit_anonymous_function_signature_return);
		csParser.block_return block211 = default(csParser.block_return);

		object string_literal209_tree=null;

		try { DebugEnterRule(GrammarFileName, "anonymous_method_expression");
		DebugLocation(228, 60);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 51)) { return retval; }
			// cs.g:228:35: ( 'delegate' ( explicit_anonymous_function_signature )? block )
			DebugEnterAlt(1);
			// cs.g:229:2: 'delegate' ( explicit_anonymous_function_signature )? block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(229, 2);
			string_literal209=(IToken)Match(input,99,Follow._99_in_anonymous_method_expression1846); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal209_tree = (object)adaptor.Create(string_literal209);
			adaptor.AddChild(root_0, string_literal209_tree);
			}
			DebugLocation(229, 15);
			// cs.g:229:15: ( explicit_anonymous_function_signature )?
			int alt57=2;
			try { DebugEnterSubRule(57);
			try { DebugEnterDecision(57, decisionCanBacktrack[57]);
			int LA57_0 = input.LA(1);

			if ((LA57_0==90))
			{
				alt57=1;
			}
			} finally { DebugExitDecision(57); }
			switch (alt57)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:229:15: explicit_anonymous_function_signature
				{
				DebugLocation(229, 15);
				PushFollow(Follow._explicit_anonymous_function_signature_in_anonymous_method_expression1850);
				explicit_anonymous_function_signature210=explicit_anonymous_function_signature();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, explicit_anonymous_function_signature210.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(57); }

			DebugLocation(229, 56);
			PushFollow(Follow._block_in_anonymous_method_expression1855);
			block211=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block211.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("anonymous_method_expression", 51);
			LeaveRule("anonymous_method_expression", 51);
			Leave_anonymous_method_expression();
			if (state.backtracking > 0) { Memoize(input, 51, anonymous_method_expression_StartIndex); }
		}
		DebugLocation(229, 60);
		} finally { DebugExitRule(GrammarFileName, "anonymous_method_expression"); }
		return retval;

	}
	// $ANTLR end "anonymous_method_expression"

	public class explicit_anonymous_function_signature_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_explicit_anonymous_function_signature();
	partial void Leave_explicit_anonymous_function_signature();

	// $ANTLR start "explicit_anonymous_function_signature"
	// cs.g:230:8: public explicit_anonymous_function_signature : '(' ( explicit_anonymous_function_parameter_list )? ')' ;
	[GrammarRule("explicit_anonymous_function_signature")]
	public csParser.explicit_anonymous_function_signature_return explicit_anonymous_function_signature()
	{
		Enter_explicit_anonymous_function_signature();
		EnterRule("explicit_anonymous_function_signature", 52);
		TraceIn("explicit_anonymous_function_signature", 52);
		csParser.explicit_anonymous_function_signature_return retval = new csParser.explicit_anonymous_function_signature_return();
		retval.Start = (IToken)input.LT(1);
		int explicit_anonymous_function_signature_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal212=null;
		IToken char_literal214=null;
		csParser.explicit_anonymous_function_parameter_list_return explicit_anonymous_function_parameter_list213 = default(csParser.explicit_anonymous_function_parameter_list_return);

		object char_literal212_tree=null;
		object char_literal214_tree=null;

		try { DebugEnterRule(GrammarFileName, "explicit_anonymous_function_signature");
		DebugLocation(230, 57);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 52)) { return retval; }
			// cs.g:230:45: ( '(' ( explicit_anonymous_function_parameter_list )? ')' )
			DebugEnterAlt(1);
			// cs.g:231:2: '(' ( explicit_anonymous_function_parameter_list )? ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(231, 2);
			char_literal212=(IToken)Match(input,90,Follow._90_in_explicit_anonymous_function_signature1864); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal212_tree = (object)adaptor.Create(char_literal212);
			adaptor.AddChild(root_0, char_literal212_tree);
			}
			DebugLocation(231, 8);
			// cs.g:231:8: ( explicit_anonymous_function_parameter_list )?
			int alt58=2;
			try { DebugEnterSubRule(58);
			try { DebugEnterDecision(58, decisionCanBacktrack[58]);
			int LA58_0 = input.LA(1);

			if ((LA58_0==IDENTIFIER||(LA58_0>=ELIF && LA58_0<=UNDEF)||LA58_0==65||LA58_0==82||(LA58_0>=93 && LA58_0<=94)||(LA58_0>=132 && LA58_0<=133)||(LA58_0>=135 && LA58_0<=148)||(LA58_0>=150 && LA58_0<=152)||LA58_0==154||(LA58_0>=156 && LA58_0<=168)||LA58_0==170||(LA58_0>=177 && LA58_0<=178)||(LA58_0>=195 && LA58_0<=202)))
			{
				alt58=1;
			}
			} finally { DebugExitDecision(58); }
			switch (alt58)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:231:8: explicit_anonymous_function_parameter_list
				{
				DebugLocation(231, 8);
				PushFollow(Follow._explicit_anonymous_function_parameter_list_in_explicit_anonymous_function_signature1868);
				explicit_anonymous_function_parameter_list213=explicit_anonymous_function_parameter_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, explicit_anonymous_function_parameter_list213.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(58); }

			DebugLocation(231, 54);
			char_literal214=(IToken)Match(input,RPAREN,Follow._RPAREN_in_explicit_anonymous_function_signature1873); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal214_tree = (object)adaptor.Create(char_literal214);
			adaptor.AddChild(root_0, char_literal214_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("explicit_anonymous_function_signature", 52);
			LeaveRule("explicit_anonymous_function_signature", 52);
			Leave_explicit_anonymous_function_signature();
			if (state.backtracking > 0) { Memoize(input, 52, explicit_anonymous_function_signature_StartIndex); }
		}
		DebugLocation(231, 57);
		} finally { DebugExitRule(GrammarFileName, "explicit_anonymous_function_signature"); }
		return retval;

	}
	// $ANTLR end "explicit_anonymous_function_signature"

	public class explicit_anonymous_function_parameter_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_explicit_anonymous_function_parameter_list();
	partial void Leave_explicit_anonymous_function_parameter_list();

	// $ANTLR start "explicit_anonymous_function_parameter_list"
	// cs.g:232:8: public explicit_anonymous_function_parameter_list : explicit_anonymous_function_parameter ( ',' explicit_anonymous_function_parameter )* ;
	[GrammarRule("explicit_anonymous_function_parameter_list")]
	public csParser.explicit_anonymous_function_parameter_list_return explicit_anonymous_function_parameter_list()
	{
		Enter_explicit_anonymous_function_parameter_list();
		EnterRule("explicit_anonymous_function_parameter_list", 53);
		TraceIn("explicit_anonymous_function_parameter_list", 53);
		csParser.explicit_anonymous_function_parameter_list_return retval = new csParser.explicit_anonymous_function_parameter_list_return();
		retval.Start = (IToken)input.LT(1);
		int explicit_anonymous_function_parameter_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal216=null;
		csParser.explicit_anonymous_function_parameter_return explicit_anonymous_function_parameter215 = default(csParser.explicit_anonymous_function_parameter_return);
		csParser.explicit_anonymous_function_parameter_return explicit_anonymous_function_parameter217 = default(csParser.explicit_anonymous_function_parameter_return);

		object char_literal216_tree=null;

		try { DebugEnterRule(GrammarFileName, "explicit_anonymous_function_parameter_list");
		DebugLocation(232, 88);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 53)) { return retval; }
			// cs.g:232:50: ( explicit_anonymous_function_parameter ( ',' explicit_anonymous_function_parameter )* )
			DebugEnterAlt(1);
			// cs.g:233:2: explicit_anonymous_function_parameter ( ',' explicit_anonymous_function_parameter )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(233, 2);
			PushFollow(Follow._explicit_anonymous_function_parameter_in_explicit_anonymous_function_parameter_list1883);
			explicit_anonymous_function_parameter215=explicit_anonymous_function_parameter();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, explicit_anonymous_function_parameter215.Tree);
			DebugLocation(233, 42);
			// cs.g:233:42: ( ',' explicit_anonymous_function_parameter )*
			try { DebugEnterSubRule(59);
			while (true)
			{
				int alt59=2;
				try { DebugEnterDecision(59, decisionCanBacktrack[59]);
				int LA59_0 = input.LA(1);

				if ((LA59_0==91))
				{
					alt59=1;
				}


				} finally { DebugExitDecision(59); }
				switch ( alt59 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:233:43: ',' explicit_anonymous_function_parameter
					{
					DebugLocation(233, 43);
					char_literal216=(IToken)Match(input,91,Follow._91_in_explicit_anonymous_function_parameter_list1888); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal216_tree = (object)adaptor.Create(char_literal216);
					adaptor.AddChild(root_0, char_literal216_tree);
					}
					DebugLocation(233, 49);
					PushFollow(Follow._explicit_anonymous_function_parameter_in_explicit_anonymous_function_parameter_list1892);
					explicit_anonymous_function_parameter217=explicit_anonymous_function_parameter();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, explicit_anonymous_function_parameter217.Tree);

					}
					break;

				default:
					goto loop59;
				}
			}

			loop59:
				;

			} finally { DebugExitSubRule(59); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("explicit_anonymous_function_parameter_list", 53);
			LeaveRule("explicit_anonymous_function_parameter_list", 53);
			Leave_explicit_anonymous_function_parameter_list();
			if (state.backtracking > 0) { Memoize(input, 53, explicit_anonymous_function_parameter_list_StartIndex); }
		}
		DebugLocation(233, 88);
		} finally { DebugExitRule(GrammarFileName, "explicit_anonymous_function_parameter_list"); }
		return retval;

	}
	// $ANTLR end "explicit_anonymous_function_parameter_list"

	public class explicit_anonymous_function_parameter_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_explicit_anonymous_function_parameter();
	partial void Leave_explicit_anonymous_function_parameter();

	// $ANTLR start "explicit_anonymous_function_parameter"
	// cs.g:234:8: public explicit_anonymous_function_parameter : ( anonymous_function_parameter_modifier )? type identifier ;
	[GrammarRule("explicit_anonymous_function_parameter")]
	public csParser.explicit_anonymous_function_parameter_return explicit_anonymous_function_parameter()
	{
		Enter_explicit_anonymous_function_parameter();
		EnterRule("explicit_anonymous_function_parameter", 54);
		TraceIn("explicit_anonymous_function_parameter", 54);
		csParser.explicit_anonymous_function_parameter_return retval = new csParser.explicit_anonymous_function_parameter_return();
		retval.Start = (IToken)input.LT(1);
		int explicit_anonymous_function_parameter_StartIndex = input.Index;
		object root_0 = null;

		csParser.anonymous_function_parameter_modifier_return anonymous_function_parameter_modifier218 = default(csParser.anonymous_function_parameter_modifier_return);
		csParser.type_return type219 = default(csParser.type_return);
		csParser.identifier_return identifier220 = default(csParser.identifier_return);


		try { DebugEnterRule(GrammarFileName, "explicit_anonymous_function_parameter");
		DebugLocation(234, 59);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 54)) { return retval; }
			// cs.g:234:45: ( ( anonymous_function_parameter_modifier )? type identifier )
			DebugEnterAlt(1);
			// cs.g:235:2: ( anonymous_function_parameter_modifier )? type identifier
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(235, 2);
			// cs.g:235:2: ( anonymous_function_parameter_modifier )?
			int alt60=2;
			try { DebugEnterSubRule(60);
			try { DebugEnterDecision(60, decisionCanBacktrack[60]);
			int LA60_0 = input.LA(1);

			if (((LA60_0>=93 && LA60_0<=94)))
			{
				alt60=1;
			}
			} finally { DebugExitDecision(60); }
			switch (alt60)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:235:2: anonymous_function_parameter_modifier
				{
				DebugLocation(235, 2);
				PushFollow(Follow._anonymous_function_parameter_modifier_in_explicit_anonymous_function_parameter1905);
				anonymous_function_parameter_modifier218=anonymous_function_parameter_modifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_function_parameter_modifier218.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(60); }

			DebugLocation(235, 43);
			PushFollow(Follow._type_in_explicit_anonymous_function_parameter1910);
			type219=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type219.Tree);
			DebugLocation(235, 50);
			PushFollow(Follow._identifier_in_explicit_anonymous_function_parameter1914);
			identifier220=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier220.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("explicit_anonymous_function_parameter", 54);
			LeaveRule("explicit_anonymous_function_parameter", 54);
			Leave_explicit_anonymous_function_parameter();
			if (state.backtracking > 0) { Memoize(input, 54, explicit_anonymous_function_parameter_StartIndex); }
		}
		DebugLocation(235, 59);
		} finally { DebugExitRule(GrammarFileName, "explicit_anonymous_function_parameter"); }
		return retval;

	}
	// $ANTLR end "explicit_anonymous_function_parameter"

	public class anonymous_function_parameter_modifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_anonymous_function_parameter_modifier();
	partial void Leave_anonymous_function_parameter_modifier();

	// $ANTLR start "anonymous_function_parameter_modifier"
	// cs.g:236:8: public anonymous_function_parameter_modifier : ( 'ref' | 'out' );
	[GrammarRule("anonymous_function_parameter_modifier")]
	public csParser.anonymous_function_parameter_modifier_return anonymous_function_parameter_modifier()
	{
		Enter_anonymous_function_parameter_modifier();
		EnterRule("anonymous_function_parameter_modifier", 55);
		TraceIn("anonymous_function_parameter_modifier", 55);
		csParser.anonymous_function_parameter_modifier_return retval = new csParser.anonymous_function_parameter_modifier_return();
		retval.Start = (IToken)input.LT(1);
		int anonymous_function_parameter_modifier_StartIndex = input.Index;
		object root_0 = null;

		IToken set221=null;

		object set221_tree=null;

		try { DebugEnterRule(GrammarFileName, "anonymous_function_parameter_modifier");
		DebugLocation(236, 14);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 55)) { return retval; }
			// cs.g:236:45: ( 'ref' | 'out' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(236, 45);
			set221=(IToken)input.LT(1);
			if ((input.LA(1)>=93 && input.LA(1)<=94))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set221));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("anonymous_function_parameter_modifier", 55);
			LeaveRule("anonymous_function_parameter_modifier", 55);
			Leave_anonymous_function_parameter_modifier();
			if (state.backtracking > 0) { Memoize(input, 55, anonymous_function_parameter_modifier_StartIndex); }
		}
		DebugLocation(237, 14);
		} finally { DebugExitRule(GrammarFileName, "anonymous_function_parameter_modifier"); }
		return retval;

	}
	// $ANTLR end "anonymous_function_parameter_modifier"

	public class object_creation_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_object_creation_expression();
	partial void Leave_object_creation_expression();

	// $ANTLR start "object_creation_expression"
	// cs.g:241:8: public object_creation_expression : type ( '(' ( argument_list )? ')' ( object_or_collection_initializer )? | object_or_collection_initializer ) ;
	[GrammarRule("object_creation_expression")]
	public csParser.object_creation_expression_return object_creation_expression()
	{
		Enter_object_creation_expression();
		EnterRule("object_creation_expression", 56);
		TraceIn("object_creation_expression", 56);
		csParser.object_creation_expression_return retval = new csParser.object_creation_expression_return();
		retval.Start = (IToken)input.LT(1);
		int object_creation_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal223=null;
		IToken char_literal225=null;
		csParser.type_return type222 = default(csParser.type_return);
		csParser.argument_list_return argument_list224 = default(csParser.argument_list_return);
		csParser.object_or_collection_initializer_return object_or_collection_initializer226 = default(csParser.object_or_collection_initializer_return);
		csParser.object_or_collection_initializer_return object_or_collection_initializer227 = default(csParser.object_or_collection_initializer_return);

		object char_literal223_tree=null;
		object char_literal225_tree=null;

		try { DebugEnterRule(GrammarFileName, "object_creation_expression");
		DebugLocation(241, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 56)) { return retval; }
			// cs.g:241:34: ( type ( '(' ( argument_list )? ')' ( object_or_collection_initializer )? | object_or_collection_initializer ) )
			DebugEnterAlt(1);
			// cs.g:243:2: type ( '(' ( argument_list )? ')' ( object_or_collection_initializer )? | object_or_collection_initializer )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(243, 2);
			PushFollow(Follow._type_in_object_creation_expression1942);
			type222=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type222.Tree);
			DebugLocation(244, 3);
			// cs.g:244:3: ( '(' ( argument_list )? ')' ( object_or_collection_initializer )? | object_or_collection_initializer )
			int alt63=2;
			try { DebugEnterSubRule(63);
			try { DebugEnterDecision(63, decisionCanBacktrack[63]);
			int LA63_0 = input.LA(1);

			if ((LA63_0==90))
			{
				alt63=1;
			}
			else if ((LA63_0==62))
			{
				alt63=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 63, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(63); }
			switch (alt63)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:244:5: '(' ( argument_list )? ')' ( object_or_collection_initializer )?
				{
				DebugLocation(244, 5);
				char_literal223=(IToken)Match(input,90,Follow._90_in_object_creation_expression1951); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal223_tree = (object)adaptor.Create(char_literal223);
				adaptor.AddChild(root_0, char_literal223_tree);
				}
				DebugLocation(244, 11);
				// cs.g:244:11: ( argument_list )?
				int alt61=2;
				try { DebugEnterSubRule(61);
				try { DebugEnterDecision(61, decisionCanBacktrack[61]);
				int LA61_0 = input.LA(1);

				if (((LA61_0>=IDENTIFIER && LA61_0<=NULL)||LA61_0==MINUS||(LA61_0>=ELIF && LA61_0<=UNDEF)||LA61_0==65||LA61_0==68||(LA61_0>=83 && LA61_0<=84)||(LA61_0>=86 && LA61_0<=87)||LA61_0==90||(LA61_0>=93 && LA61_0<=100)||LA61_0==102||(LA61_0>=104 && LA61_0<=106)||LA61_0==117||(LA61_0>=132 && LA61_0<=133)||(LA61_0>=135 && LA61_0<=148)||(LA61_0>=150 && LA61_0<=152)||LA61_0==154||(LA61_0>=156 && LA61_0<=168)||LA61_0==170||(LA61_0>=177 && LA61_0<=178)||(LA61_0>=195 && LA61_0<=202)))
				{
					alt61=1;
				}
				} finally { DebugExitDecision(61); }
				switch (alt61)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:244:11: argument_list
					{
					DebugLocation(244, 11);
					PushFollow(Follow._argument_list_in_object_creation_expression1955);
					argument_list224=argument_list();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_list224.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(61); }

				DebugLocation(244, 28);
				char_literal225=(IToken)Match(input,RPAREN,Follow._RPAREN_in_object_creation_expression1960); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal225_tree = (object)adaptor.Create(char_literal225);
				adaptor.AddChild(root_0, char_literal225_tree);
				}
				DebugLocation(244, 34);
				// cs.g:244:34: ( object_or_collection_initializer )?
				int alt62=2;
				try { DebugEnterSubRule(62);
				try { DebugEnterDecision(62, decisionCanBacktrack[62]);
				int LA62_0 = input.LA(1);

				if ((LA62_0==62))
				{
					alt62=1;
				}
				} finally { DebugExitDecision(62); }
				switch (alt62)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:244:34: object_or_collection_initializer
					{
					DebugLocation(244, 34);
					PushFollow(Follow._object_or_collection_initializer_in_object_creation_expression1964);
					object_or_collection_initializer226=object_or_collection_initializer();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_or_collection_initializer226.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(62); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:245:7: object_or_collection_initializer
				{
				DebugLocation(245, 7);
				PushFollow(Follow._object_or_collection_initializer_in_object_creation_expression1975);
				object_or_collection_initializer227=object_or_collection_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_or_collection_initializer227.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(63); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("object_creation_expression", 56);
			LeaveRule("object_creation_expression", 56);
			Leave_object_creation_expression();
			if (state.backtracking > 0) { Memoize(input, 56, object_creation_expression_StartIndex); }
		}
		DebugLocation(246, 1);
		} finally { DebugExitRule(GrammarFileName, "object_creation_expression"); }
		return retval;

	}
	// $ANTLR end "object_creation_expression"

	public class object_or_collection_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_object_or_collection_initializer();
	partial void Leave_object_or_collection_initializer();

	// $ANTLR start "object_or_collection_initializer"
	// cs.g:247:8: public object_or_collection_initializer : '{' ( object_initializer | collection_initializer ) ;
	[GrammarRule("object_or_collection_initializer")]
	public csParser.object_or_collection_initializer_return object_or_collection_initializer()
	{
		Enter_object_or_collection_initializer();
		EnterRule("object_or_collection_initializer", 57);
		TraceIn("object_or_collection_initializer", 57);
		csParser.object_or_collection_initializer_return retval = new csParser.object_or_collection_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int object_or_collection_initializer_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal228=null;
		csParser.object_initializer_return object_initializer229 = default(csParser.object_initializer_return);
		csParser.collection_initializer_return collection_initializer230 = default(csParser.collection_initializer_return);

		object char_literal228_tree=null;

		try { DebugEnterRule(GrammarFileName, "object_or_collection_initializer");
		DebugLocation(247, 28);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 57)) { return retval; }
			// cs.g:247:40: ( '{' ( object_initializer | collection_initializer ) )
			DebugEnterAlt(1);
			// cs.g:248:2: '{' ( object_initializer | collection_initializer )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(248, 2);
			char_literal228=(IToken)Match(input,62,Follow._62_in_object_or_collection_initializer1989); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal228_tree = (object)adaptor.Create(char_literal228);
			adaptor.AddChild(root_0, char_literal228_tree);
			}
			DebugLocation(248, 7);
			// cs.g:248:7: ( object_initializer | collection_initializer )
			int alt64=2;
			try { DebugEnterSubRule(64);
			try { DebugEnterDecision(64, decisionCanBacktrack[64]);
			switch (input.LA(1))
			{
			case IDENTIFIER:
				{
				int LA64_1 = input.LA(2);

				if ((LA64_1==66))
				{
					alt64=1;
				}
				else if (((LA64_1>=DOT && LA64_1<=GT)||LA64_1==63||(LA64_1>=85 && LA64_1<=88)||(LA64_1>=90 && LA64_1<=91)||(LA64_1>=101 && LA64_1<=104)||(LA64_1>=116 && LA64_1<=131)))
				{
					alt64=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 64, 1, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case 133:
				{
				int LA64_2 = input.LA(2);

				if ((LA64_2==66))
				{
					alt64=1;
				}
				else if ((LA64_2==IDENTIFIER||(LA64_2>=DOT && LA64_2<=GT)||(LA64_2>=ELIF && LA64_2<=UNDEF)||LA64_2==63||LA64_2==65||LA64_2==82||(LA64_2>=85 && LA64_2<=88)||(LA64_2>=90 && LA64_2<=91)||(LA64_2>=101 && LA64_2<=104)||(LA64_2>=116 && LA64_2<=133)||(LA64_2>=135 && LA64_2<=148)||(LA64_2>=150 && LA64_2<=152)||LA64_2==154||(LA64_2>=156 && LA64_2<=168)||LA64_2==170||(LA64_2>=177 && LA64_2<=178)||(LA64_2>=195 && LA64_2<=202)))
				{
					alt64=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 64, 2, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case 63:
			case 91:
				{
				alt64=1;
				}
				break;
			case Real_literal:
			case NUMBER:
			case Hex_number:
			case Character_literal:
			case STRINGLITERAL:
			case Verbatim_string_literal:
			case TRUE:
			case FALSE:
			case NULL:
			case MINUS:
			case 62:
			case 68:
			case 83:
			case 84:
			case 86:
			case 87:
			case 90:
			case 95:
			case 96:
			case 97:
			case 98:
			case 99:
			case 100:
			case 102:
			case 104:
			case 105:
			case 106:
			case 117:
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 196:
			case 197:
			case 198:
			case 199:
			case 200:
			case 201:
				{
				alt64=2;
				}
				break;
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 132:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 170:
			case 177:
			case 178:
			case 195:
			case 202:
				{
				int LA64_5 = input.LA(2);

				if ((LA64_5==66))
				{
					alt64=1;
				}
				else if (((LA64_5>=DOT && LA64_5<=GT)||LA64_5==63||(LA64_5>=85 && LA64_5<=88)||(LA64_5>=90 && LA64_5<=91)||(LA64_5>=101 && LA64_5<=104)||(LA64_5>=116 && LA64_5<=131)))
				{
					alt64=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 64, 5, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 64, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(64); }
			switch (alt64)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:248:8: object_initializer
				{
				DebugLocation(248, 8);
				PushFollow(Follow._object_initializer_in_object_or_collection_initializer1993);
				object_initializer229=object_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_initializer229.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:249:5: collection_initializer
				{
				DebugLocation(249, 5);
				PushFollow(Follow._collection_initializer_in_object_or_collection_initializer2000);
				collection_initializer230=collection_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, collection_initializer230.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(64); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("object_or_collection_initializer", 57);
			LeaveRule("object_or_collection_initializer", 57);
			Leave_object_or_collection_initializer();
			if (state.backtracking > 0) { Memoize(input, 57, object_or_collection_initializer_StartIndex); }
		}
		DebugLocation(249, 28);
		} finally { DebugExitRule(GrammarFileName, "object_or_collection_initializer"); }
		return retval;

	}
	// $ANTLR end "object_or_collection_initializer"

	public class collection_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_collection_initializer();
	partial void Leave_collection_initializer();

	// $ANTLR start "collection_initializer"
	// cs.g:250:8: public collection_initializer : element_initializer_list ( ',' )? '}' ;
	[GrammarRule("collection_initializer")]
	public csParser.collection_initializer_return collection_initializer()
	{
		Enter_collection_initializer();
		EnterRule("collection_initializer", 58);
		TraceIn("collection_initializer", 58);
		csParser.collection_initializer_return retval = new csParser.collection_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int collection_initializer_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal232=null;
		IToken char_literal233=null;
		csParser.element_initializer_list_return element_initializer_list231 = default(csParser.element_initializer_list_return);

		object char_literal232_tree=null;
		object char_literal233_tree=null;

		try { DebugEnterRule(GrammarFileName, "collection_initializer");
		DebugLocation(250, 39);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 58)) { return retval; }
			// cs.g:250:30: ( element_initializer_list ( ',' )? '}' )
			DebugEnterAlt(1);
			// cs.g:251:2: element_initializer_list ( ',' )? '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(251, 2);
			PushFollow(Follow._element_initializer_list_in_collection_initializer2012);
			element_initializer_list231=element_initializer_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, element_initializer_list231.Tree);
			DebugLocation(251, 29);
			// cs.g:251:29: ( ',' )?
			int alt65=2;
			try { DebugEnterSubRule(65);
			try { DebugEnterDecision(65, decisionCanBacktrack[65]);
			int LA65_0 = input.LA(1);

			if ((LA65_0==91))
			{
				alt65=1;
			}
			} finally { DebugExitDecision(65); }
			switch (alt65)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:251:29: ','
				{
				DebugLocation(251, 29);
				char_literal232=(IToken)Match(input,91,Follow._91_in_collection_initializer2016); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal232_tree = (object)adaptor.Create(char_literal232);
				adaptor.AddChild(root_0, char_literal232_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(65); }

			DebugLocation(251, 36);
			char_literal233=(IToken)Match(input,63,Follow._63_in_collection_initializer2021); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal233_tree = (object)adaptor.Create(char_literal233);
			adaptor.AddChild(root_0, char_literal233_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("collection_initializer", 58);
			LeaveRule("collection_initializer", 58);
			Leave_collection_initializer();
			if (state.backtracking > 0) { Memoize(input, 58, collection_initializer_StartIndex); }
		}
		DebugLocation(251, 39);
		} finally { DebugExitRule(GrammarFileName, "collection_initializer"); }
		return retval;

	}
	// $ANTLR end "collection_initializer"

	public class element_initializer_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_element_initializer_list();
	partial void Leave_element_initializer_list();

	// $ANTLR start "element_initializer_list"
	// cs.g:252:8: public element_initializer_list : element_initializer ( ',' element_initializer )* ;
	[GrammarRule("element_initializer_list")]
	public csParser.element_initializer_list_return element_initializer_list()
	{
		Enter_element_initializer_list();
		EnterRule("element_initializer_list", 59);
		TraceIn("element_initializer_list", 59);
		csParser.element_initializer_list_return retval = new csParser.element_initializer_list_return();
		retval.Start = (IToken)input.LT(1);
		int element_initializer_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal235=null;
		csParser.element_initializer_return element_initializer234 = default(csParser.element_initializer_return);
		csParser.element_initializer_return element_initializer236 = default(csParser.element_initializer_return);

		object char_literal235_tree=null;

		try { DebugEnterRule(GrammarFileName, "element_initializer_list");
		DebugLocation(252, 49);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 59)) { return retval; }
			// cs.g:252:32: ( element_initializer ( ',' element_initializer )* )
			DebugEnterAlt(1);
			// cs.g:253:2: element_initializer ( ',' element_initializer )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(253, 2);
			PushFollow(Follow._element_initializer_in_element_initializer_list2032);
			element_initializer234=element_initializer();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, element_initializer234.Tree);
			DebugLocation(253, 23);
			// cs.g:253:23: ( ',' element_initializer )*
			try { DebugEnterSubRule(66);
			while (true)
			{
				int alt66=2;
				try { DebugEnterDecision(66, decisionCanBacktrack[66]);
				int LA66_0 = input.LA(1);

				if ((LA66_0==91))
				{
					int LA66_1 = input.LA(2);

					if (((LA66_1>=IDENTIFIER && LA66_1<=NULL)||LA66_1==MINUS||(LA66_1>=ELIF && LA66_1<=UNDEF)||LA66_1==62||LA66_1==65||LA66_1==68||(LA66_1>=83 && LA66_1<=84)||(LA66_1>=86 && LA66_1<=87)||LA66_1==90||(LA66_1>=95 && LA66_1<=100)||LA66_1==102||(LA66_1>=104 && LA66_1<=106)||LA66_1==117||(LA66_1>=132 && LA66_1<=133)||(LA66_1>=135 && LA66_1<=148)||(LA66_1>=150 && LA66_1<=152)||LA66_1==154||(LA66_1>=156 && LA66_1<=168)||LA66_1==170||(LA66_1>=177 && LA66_1<=178)||(LA66_1>=195 && LA66_1<=202)))
					{
						alt66=1;
					}


				}


				} finally { DebugExitDecision(66); }
				switch ( alt66 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:253:24: ',' element_initializer
					{
					DebugLocation(253, 24);
					char_literal235=(IToken)Match(input,91,Follow._91_in_element_initializer_list2036); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal235_tree = (object)adaptor.Create(char_literal235);
					adaptor.AddChild(root_0, char_literal235_tree);
					}
					DebugLocation(253, 28);
					PushFollow(Follow._element_initializer_in_element_initializer_list2038);
					element_initializer236=element_initializer();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, element_initializer236.Tree);

					}
					break;

				default:
					goto loop66;
				}
			}

			loop66:
				;

			} finally { DebugExitSubRule(66); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("element_initializer_list", 59);
			LeaveRule("element_initializer_list", 59);
			Leave_element_initializer_list();
			if (state.backtracking > 0) { Memoize(input, 59, element_initializer_list_StartIndex); }
		}
		DebugLocation(253, 49);
		} finally { DebugExitRule(GrammarFileName, "element_initializer_list"); }
		return retval;

	}
	// $ANTLR end "element_initializer_list"

	public class element_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_element_initializer();
	partial void Leave_element_initializer();

	// $ANTLR start "element_initializer"
	// cs.g:254:8: public element_initializer : ( non_assignment_expression | '{' expression_list '}' );
	[GrammarRule("element_initializer")]
	public csParser.element_initializer_return element_initializer()
	{
		Enter_element_initializer();
		EnterRule("element_initializer", 60);
		TraceIn("element_initializer", 60);
		csParser.element_initializer_return retval = new csParser.element_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int element_initializer_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal238=null;
		IToken char_literal240=null;
		csParser.non_assignment_expression_return non_assignment_expression237 = default(csParser.non_assignment_expression_return);
		csParser.expression_list_return expression_list239 = default(csParser.expression_list_return);

		object char_literal238_tree=null;
		object char_literal240_tree=null;

		try { DebugEnterRule(GrammarFileName, "element_initializer");
		DebugLocation(254, 31);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 60)) { return retval; }
			// cs.g:254:27: ( non_assignment_expression | '{' expression_list '}' )
			int alt67=2;
			try { DebugEnterDecision(67, decisionCanBacktrack[67]);
			int LA67_0 = input.LA(1);

			if (((LA67_0>=IDENTIFIER && LA67_0<=NULL)||LA67_0==MINUS||(LA67_0>=ELIF && LA67_0<=UNDEF)||LA67_0==65||LA67_0==68||(LA67_0>=83 && LA67_0<=84)||(LA67_0>=86 && LA67_0<=87)||LA67_0==90||(LA67_0>=95 && LA67_0<=100)||LA67_0==102||(LA67_0>=104 && LA67_0<=106)||LA67_0==117||(LA67_0>=132 && LA67_0<=133)||(LA67_0>=135 && LA67_0<=148)||(LA67_0>=150 && LA67_0<=152)||LA67_0==154||(LA67_0>=156 && LA67_0<=168)||LA67_0==170||(LA67_0>=177 && LA67_0<=178)||(LA67_0>=195 && LA67_0<=202)))
			{
				alt67=1;
			}
			else if ((LA67_0==62))
			{
				alt67=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 67, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(67); }
			switch (alt67)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:255:2: non_assignment_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(255, 2);
				PushFollow(Follow._non_assignment_expression_in_element_initializer2051);
				non_assignment_expression237=non_assignment_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, non_assignment_expression237.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:256:4: '{' expression_list '}'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(256, 4);
				char_literal238=(IToken)Match(input,62,Follow._62_in_element_initializer2057); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal238_tree = (object)adaptor.Create(char_literal238);
				adaptor.AddChild(root_0, char_literal238_tree);
				}
				DebugLocation(256, 10);
				PushFollow(Follow._expression_list_in_element_initializer2061);
				expression_list239=expression_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression_list239.Tree);
				DebugLocation(256, 28);
				char_literal240=(IToken)Match(input,63,Follow._63_in_element_initializer2065); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal240_tree = (object)adaptor.Create(char_literal240);
				adaptor.AddChild(root_0, char_literal240_tree);
				}

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("element_initializer", 60);
			LeaveRule("element_initializer", 60);
			Leave_element_initializer();
			if (state.backtracking > 0) { Memoize(input, 60, element_initializer_StartIndex); }
		}
		DebugLocation(256, 31);
		} finally { DebugExitRule(GrammarFileName, "element_initializer"); }
		return retval;

	}
	// $ANTLR end "element_initializer"

	public class object_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_object_initializer();
	partial void Leave_object_initializer();

	// $ANTLR start "object_initializer"
	// cs.g:263:8: public object_initializer : ( member_initializer_list )? ( ',' )? '}' ;
	[GrammarRule("object_initializer")]
	public csParser.object_initializer_return object_initializer()
	{
		Enter_object_initializer();
		EnterRule("object_initializer", 61);
		TraceIn("object_initializer", 61);
		csParser.object_initializer_return retval = new csParser.object_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int object_initializer_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal242=null;
		IToken char_literal243=null;
		csParser.member_initializer_list_return member_initializer_list241 = default(csParser.member_initializer_list_return);

		object char_literal242_tree=null;
		object char_literal243_tree=null;

		try { DebugEnterRule(GrammarFileName, "object_initializer");
		DebugLocation(263, 39);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 61)) { return retval; }
			// cs.g:263:26: ( ( member_initializer_list )? ( ',' )? '}' )
			DebugEnterAlt(1);
			// cs.g:264:2: ( member_initializer_list )? ( ',' )? '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(264, 2);
			// cs.g:264:2: ( member_initializer_list )?
			int alt68=2;
			try { DebugEnterSubRule(68);
			try { DebugEnterDecision(68, decisionCanBacktrack[68]);
			int LA68_0 = input.LA(1);

			if ((LA68_0==IDENTIFIER||(LA68_0>=ELIF && LA68_0<=UNDEF)||LA68_0==65||(LA68_0>=132 && LA68_0<=133)||(LA68_0>=135 && LA68_0<=148)||(LA68_0>=150 && LA68_0<=152)||LA68_0==154||(LA68_0>=156 && LA68_0<=159)||LA68_0==170||(LA68_0>=177 && LA68_0<=178)||LA68_0==195||LA68_0==202))
			{
				alt68=1;
			}
			} finally { DebugExitDecision(68); }
			switch (alt68)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:264:2: member_initializer_list
				{
				DebugLocation(264, 2);
				PushFollow(Follow._member_initializer_list_in_object_initializer2082);
				member_initializer_list241=member_initializer_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_initializer_list241.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(68); }

			DebugLocation(264, 29);
			// cs.g:264:29: ( ',' )?
			int alt69=2;
			try { DebugEnterSubRule(69);
			try { DebugEnterDecision(69, decisionCanBacktrack[69]);
			int LA69_0 = input.LA(1);

			if ((LA69_0==91))
			{
				alt69=1;
			}
			} finally { DebugExitDecision(69); }
			switch (alt69)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:264:29: ','
				{
				DebugLocation(264, 29);
				char_literal242=(IToken)Match(input,91,Follow._91_in_object_initializer2087); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal242_tree = (object)adaptor.Create(char_literal242);
				adaptor.AddChild(root_0, char_literal242_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(69); }

			DebugLocation(264, 36);
			char_literal243=(IToken)Match(input,63,Follow._63_in_object_initializer2092); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal243_tree = (object)adaptor.Create(char_literal243);
			adaptor.AddChild(root_0, char_literal243_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("object_initializer", 61);
			LeaveRule("object_initializer", 61);
			Leave_object_initializer();
			if (state.backtracking > 0) { Memoize(input, 61, object_initializer_StartIndex); }
		}
		DebugLocation(264, 39);
		} finally { DebugExitRule(GrammarFileName, "object_initializer"); }
		return retval;

	}
	// $ANTLR end "object_initializer"

	public class member_initializer_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_member_initializer_list();
	partial void Leave_member_initializer_list();

	// $ANTLR start "member_initializer_list"
	// cs.g:265:8: public member_initializer_list : member_initializer ( ',' member_initializer ) ;
	[GrammarRule("member_initializer_list")]
	public csParser.member_initializer_list_return member_initializer_list()
	{
		Enter_member_initializer_list();
		EnterRule("member_initializer_list", 62);
		TraceIn("member_initializer_list", 62);
		csParser.member_initializer_list_return retval = new csParser.member_initializer_list_return();
		retval.Start = (IToken)input.LT(1);
		int member_initializer_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal245=null;
		csParser.member_initializer_return member_initializer244 = default(csParser.member_initializer_return);
		csParser.member_initializer_return member_initializer246 = default(csParser.member_initializer_return);

		object char_literal245_tree=null;

		try { DebugEnterRule(GrammarFileName, "member_initializer_list");
		DebugLocation(265, 46);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 62)) { return retval; }
			// cs.g:265:31: ( member_initializer ( ',' member_initializer ) )
			DebugEnterAlt(1);
			// cs.g:266:2: member_initializer ( ',' member_initializer )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(266, 2);
			PushFollow(Follow._member_initializer_in_member_initializer_list2103);
			member_initializer244=member_initializer();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_initializer244.Tree);
			DebugLocation(266, 22);
			// cs.g:266:22: ( ',' member_initializer )
			DebugEnterAlt(1);
			// cs.g:266:23: ',' member_initializer
			{
			DebugLocation(266, 23);
			char_literal245=(IToken)Match(input,91,Follow._91_in_member_initializer_list2107); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal245_tree = (object)adaptor.Create(char_literal245);
			adaptor.AddChild(root_0, char_literal245_tree);
			}
			DebugLocation(266, 27);
			PushFollow(Follow._member_initializer_in_member_initializer_list2109);
			member_initializer246=member_initializer();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_initializer246.Tree);

			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("member_initializer_list", 62);
			LeaveRule("member_initializer_list", 62);
			Leave_member_initializer_list();
			if (state.backtracking > 0) { Memoize(input, 62, member_initializer_list_StartIndex); }
		}
		DebugLocation(266, 46);
		} finally { DebugExitRule(GrammarFileName, "member_initializer_list"); }
		return retval;

	}
	// $ANTLR end "member_initializer_list"

	public class member_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_member_initializer();
	partial void Leave_member_initializer();

	// $ANTLR start "member_initializer"
	// cs.g:267:8: public member_initializer : identifier '=' initializer_value ;
	[GrammarRule("member_initializer")]
	public csParser.member_initializer_return member_initializer()
	{
		Enter_member_initializer();
		EnterRule("member_initializer", 63);
		TraceIn("member_initializer", 63);
		csParser.member_initializer_return retval = new csParser.member_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int member_initializer_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal248=null;
		csParser.identifier_return identifier247 = default(csParser.identifier_return);
		csParser.initializer_value_return initializer_value249 = default(csParser.initializer_value_return);

		object char_literal248_tree=null;

		try { DebugEnterRule(GrammarFileName, "member_initializer");
		DebugLocation(267, 38);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 63)) { return retval; }
			// cs.g:267:26: ( identifier '=' initializer_value )
			DebugEnterAlt(1);
			// cs.g:268:2: identifier '=' initializer_value
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(268, 2);
			PushFollow(Follow._identifier_in_member_initializer2121);
			identifier247=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier247.Tree);
			DebugLocation(268, 15);
			char_literal248=(IToken)Match(input,66,Follow._66_in_member_initializer2125); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal248_tree = (object)adaptor.Create(char_literal248);
			adaptor.AddChild(root_0, char_literal248_tree);
			}
			DebugLocation(268, 21);
			PushFollow(Follow._initializer_value_in_member_initializer2129);
			initializer_value249=initializer_value();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, initializer_value249.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("member_initializer", 63);
			LeaveRule("member_initializer", 63);
			Leave_member_initializer();
			if (state.backtracking > 0) { Memoize(input, 63, member_initializer_StartIndex); }
		}
		DebugLocation(268, 38);
		} finally { DebugExitRule(GrammarFileName, "member_initializer"); }
		return retval;

	}
	// $ANTLR end "member_initializer"

	public class initializer_value_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_initializer_value();
	partial void Leave_initializer_value();

	// $ANTLR start "initializer_value"
	// cs.g:269:8: public initializer_value : ( expression | object_or_collection_initializer );
	[GrammarRule("initializer_value")]
	public csParser.initializer_value_return initializer_value()
	{
		Enter_initializer_value();
		EnterRule("initializer_value", 64);
		TraceIn("initializer_value", 64);
		csParser.initializer_value_return retval = new csParser.initializer_value_return();
		retval.Start = (IToken)input.LT(1);
		int initializer_value_StartIndex = input.Index;
		object root_0 = null;

		csParser.expression_return expression250 = default(csParser.expression_return);
		csParser.object_or_collection_initializer_return object_or_collection_initializer251 = default(csParser.object_or_collection_initializer_return);


		try { DebugEnterRule(GrammarFileName, "initializer_value");
		DebugLocation(269, 36);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 64)) { return retval; }
			// cs.g:269:25: ( expression | object_or_collection_initializer )
			int alt70=2;
			try { DebugEnterDecision(70, decisionCanBacktrack[70]);
			int LA70_0 = input.LA(1);

			if (((LA70_0>=IDENTIFIER && LA70_0<=NULL)||LA70_0==MINUS||(LA70_0>=ELIF && LA70_0<=UNDEF)||LA70_0==65||LA70_0==68||(LA70_0>=83 && LA70_0<=84)||(LA70_0>=86 && LA70_0<=87)||LA70_0==90||(LA70_0>=95 && LA70_0<=100)||LA70_0==102||(LA70_0>=104 && LA70_0<=106)||LA70_0==117||(LA70_0>=132 && LA70_0<=133)||(LA70_0>=135 && LA70_0<=148)||(LA70_0>=150 && LA70_0<=152)||LA70_0==154||(LA70_0>=156 && LA70_0<=168)||LA70_0==170||(LA70_0>=177 && LA70_0<=178)||(LA70_0>=195 && LA70_0<=202)))
			{
				alt70=1;
			}
			else if ((LA70_0==62))
			{
				alt70=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 70, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(70); }
			switch (alt70)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:270:2: expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(270, 2);
				PushFollow(Follow._expression_in_initializer_value2140);
				expression250=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression250.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:271:4: object_or_collection_initializer
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(271, 4);
				PushFollow(Follow._object_or_collection_initializer_in_initializer_value2146);
				object_or_collection_initializer251=object_or_collection_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_or_collection_initializer251.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("initializer_value", 64);
			LeaveRule("initializer_value", 64);
			Leave_initializer_value();
			if (state.backtracking > 0) { Memoize(input, 64, initializer_value_StartIndex); }
		}
		DebugLocation(271, 36);
		} finally { DebugExitRule(GrammarFileName, "initializer_value"); }
		return retval;

	}
	// $ANTLR end "initializer_value"

	public class typeof_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_typeof_expression();
	partial void Leave_typeof_expression();

	// $ANTLR start "typeof_expression"
	// cs.g:275:8: public typeof_expression : 'typeof' '(' ( ( unbound_type_name )=> unbound_type_name | type | 'void' ) ')' ;
	[GrammarRule("typeof_expression")]
	public csParser.typeof_expression_return typeof_expression()
	{
		Enter_typeof_expression();
		EnterRule("typeof_expression", 65);
		TraceIn("typeof_expression", 65);
		csParser.typeof_expression_return retval = new csParser.typeof_expression_return();
		retval.Start = (IToken)input.LT(1);
		int typeof_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal252=null;
		IToken char_literal253=null;
		IToken string_literal256=null;
		IToken char_literal257=null;
		csParser.unbound_type_name_return unbound_type_name254 = default(csParser.unbound_type_name_return);
		csParser.type_return type255 = default(csParser.type_return);

		object string_literal252_tree=null;
		object char_literal253_tree=null;
		object string_literal256_tree=null;
		object char_literal257_tree=null;

		try { DebugEnterRule(GrammarFileName, "typeof_expression");
		DebugLocation(275, 23);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 65)) { return retval; }
			// cs.g:275:25: ( 'typeof' '(' ( ( unbound_type_name )=> unbound_type_name | type | 'void' ) ')' )
			DebugEnterAlt(1);
			// cs.g:276:2: 'typeof' '(' ( ( unbound_type_name )=> unbound_type_name | type | 'void' ) ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(276, 2);
			string_literal252=(IToken)Match(input,100,Follow._100_in_typeof_expression2160); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal252_tree = (object)adaptor.Create(string_literal252);
			adaptor.AddChild(root_0, string_literal252_tree);
			}
			DebugLocation(276, 13);
			char_literal253=(IToken)Match(input,90,Follow._90_in_typeof_expression2164); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal253_tree = (object)adaptor.Create(char_literal253);
			adaptor.AddChild(root_0, char_literal253_tree);
			}
			DebugLocation(276, 19);
			// cs.g:276:19: ( ( unbound_type_name )=> unbound_type_name | type | 'void' )
			int alt71=3;
			try { DebugEnterSubRule(71);
			try { DebugEnterDecision(71, decisionCanBacktrack[71]);
			try
			{
				alt71 = dfa71.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(71); }
			switch (alt71)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:276:20: ( unbound_type_name )=> unbound_type_name
				{
				DebugLocation(276, 43);
				PushFollow(Follow._unbound_type_name_in_typeof_expression2175);
				unbound_type_name254=unbound_type_name();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unbound_type_name254.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:277:10: type
				{
				DebugLocation(277, 10);
				PushFollow(Follow._type_in_typeof_expression2186);
				type255=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type255.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:278:10: 'void'
				{
				DebugLocation(278, 10);
				string_literal256=(IToken)Match(input,82,Follow._82_in_typeof_expression2198); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal256_tree = (object)adaptor.Create(string_literal256);
				adaptor.AddChild(root_0, string_literal256_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(71); }

			DebugLocation(278, 20);
			char_literal257=(IToken)Match(input,RPAREN,Follow._RPAREN_in_typeof_expression2203); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal257_tree = (object)adaptor.Create(char_literal257);
			adaptor.AddChild(root_0, char_literal257_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("typeof_expression", 65);
			LeaveRule("typeof_expression", 65);
			Leave_typeof_expression();
			if (state.backtracking > 0) { Memoize(input, 65, typeof_expression_StartIndex); }
		}
		DebugLocation(278, 23);
		} finally { DebugExitRule(GrammarFileName, "typeof_expression"); }
		return retval;

	}
	// $ANTLR end "typeof_expression"

	public class unbound_type_name_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_unbound_type_name();
	partial void Leave_unbound_type_name();

	// $ANTLR start "unbound_type_name"
	// cs.g:283:8: public unbound_type_name : unbound_type_name_start ( ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part ) | unbound_type_name_part )* generic_dimension_specifier ;
	[GrammarRule("unbound_type_name")]
	public csParser.unbound_type_name_return unbound_type_name()
	{
		Enter_unbound_type_name();
		EnterRule("unbound_type_name", 66);
		TraceIn("unbound_type_name", 66);
		csParser.unbound_type_name_return retval = new csParser.unbound_type_name_return();
		retval.Start = (IToken)input.LT(1);
		int unbound_type_name_StartIndex = input.Index;
		object root_0 = null;

		csParser.unbound_type_name_start_return unbound_type_name_start258 = default(csParser.unbound_type_name_start_return);
		csParser.generic_dimension_specifier_return generic_dimension_specifier259 = default(csParser.generic_dimension_specifier_return);
		csParser.unbound_type_name_part_return unbound_type_name_part260 = default(csParser.unbound_type_name_part_return);
		csParser.unbound_type_name_part_return unbound_type_name_part261 = default(csParser.unbound_type_name_part_return);
		csParser.generic_dimension_specifier_return generic_dimension_specifier262 = default(csParser.generic_dimension_specifier_return);


		try { DebugEnterRule(GrammarFileName, "unbound_type_name");
		DebugLocation(283, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 66)) { return retval; }
			// cs.g:283:25: ( unbound_type_name_start ( ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part ) | unbound_type_name_part )* generic_dimension_specifier )
			DebugEnterAlt(1);
			// cs.g:285:2: unbound_type_name_start ( ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part ) | unbound_type_name_part )* generic_dimension_specifier
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(285, 2);
			PushFollow(Follow._unbound_type_name_start_in_unbound_type_name2220);
			unbound_type_name_start258=unbound_type_name_start();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unbound_type_name_start258.Tree);
			DebugLocation(286, 3);
			// cs.g:286:3: ( ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part ) | unbound_type_name_part )*
			try { DebugEnterSubRule(72);
			while (true)
			{
				int alt72=3;
				try { DebugEnterDecision(72, decisionCanBacktrack[72]);
				try
				{
					alt72 = dfa72.Predict(input);
				}
				catch (NoViableAltException nvae)
				{
					DebugRecognitionException(nvae);
					throw;
				}
				} finally { DebugExitDecision(72); }
				switch ( alt72 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:286:4: ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part )
					{
					DebugLocation(286, 4);
					// cs.g:286:4: ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part )
					DebugEnterAlt(1);
					// cs.g:286:5: ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part
					{
					DebugLocation(286, 44);
					PushFollow(Follow._generic_dimension_specifier_in_unbound_type_name2239);
					generic_dimension_specifier259=generic_dimension_specifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_dimension_specifier259.Tree);
					DebugLocation(286, 74);
					PushFollow(Follow._unbound_type_name_part_in_unbound_type_name2243);
					unbound_type_name_part260=unbound_type_name_part();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unbound_type_name_part260.Tree);

					}


					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:287:5: unbound_type_name_part
					{
					DebugLocation(287, 5);
					PushFollow(Follow._unbound_type_name_part_in_unbound_type_name2250);
					unbound_type_name_part261=unbound_type_name_part();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unbound_type_name_part261.Tree);

					}
					break;

				default:
					goto loop72;
				}
			}

			loop72:
				;

			} finally { DebugExitSubRule(72); }

			DebugLocation(288, 4);
			PushFollow(Follow._generic_dimension_specifier_in_unbound_type_name2260);
			generic_dimension_specifier262=generic_dimension_specifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_dimension_specifier262.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("unbound_type_name", 66);
			LeaveRule("unbound_type_name", 66);
			Leave_unbound_type_name();
			if (state.backtracking > 0) { Memoize(input, 66, unbound_type_name_StartIndex); }
		}
		DebugLocation(289, 1);
		} finally { DebugExitRule(GrammarFileName, "unbound_type_name"); }
		return retval;

	}
	// $ANTLR end "unbound_type_name"

	public class unbound_type_name_start_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_unbound_type_name_start();
	partial void Leave_unbound_type_name_start();

	// $ANTLR start "unbound_type_name_start"
	// cs.g:291:8: public unbound_type_name_start : identifier ( '::' identifier )? ;
	[GrammarRule("unbound_type_name_start")]
	public csParser.unbound_type_name_start_return unbound_type_name_start()
	{
		Enter_unbound_type_name_start();
		EnterRule("unbound_type_name_start", 67);
		TraceIn("unbound_type_name_start", 67);
		csParser.unbound_type_name_start_return retval = new csParser.unbound_type_name_start_return();
		retval.Start = (IToken)input.LT(1);
		int unbound_type_name_start_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal264=null;
		csParser.identifier_return identifier263 = default(csParser.identifier_return);
		csParser.identifier_return identifier265 = default(csParser.identifier_return);

		object string_literal264_tree=null;

		try { DebugEnterRule(GrammarFileName, "unbound_type_name_start");
		DebugLocation(291, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 67)) { return retval; }
			// cs.g:291:31: ( identifier ( '::' identifier )? )
			DebugEnterAlt(1);
			// cs.g:292:2: identifier ( '::' identifier )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(292, 2);
			PushFollow(Follow._identifier_in_unbound_type_name_start2272);
			identifier263=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier263.Tree);
			DebugLocation(292, 13);
			// cs.g:292:13: ( '::' identifier )?
			int alt73=2;
			try { DebugEnterSubRule(73);
			try { DebugEnterDecision(73, decisionCanBacktrack[73]);
			int LA73_0 = input.LA(1);

			if ((LA73_0==85))
			{
				alt73=1;
			}
			} finally { DebugExitDecision(73); }
			switch (alt73)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:292:14: '::' identifier
				{
				DebugLocation(292, 14);
				string_literal264=(IToken)Match(input,85,Follow._85_in_unbound_type_name_start2275); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal264_tree = (object)adaptor.Create(string_literal264);
				adaptor.AddChild(root_0, string_literal264_tree);
				}
				DebugLocation(292, 19);
				PushFollow(Follow._identifier_in_unbound_type_name_start2277);
				identifier265=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier265.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(73); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("unbound_type_name_start", 67);
			LeaveRule("unbound_type_name_start", 67);
			Leave_unbound_type_name_start();
			if (state.backtracking > 0) { Memoize(input, 67, unbound_type_name_start_StartIndex); }
		}
		DebugLocation(292, 30);
		} finally { DebugExitRule(GrammarFileName, "unbound_type_name_start"); }
		return retval;

	}
	// $ANTLR end "unbound_type_name_start"

	public class unbound_type_name_part_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_unbound_type_name_part();
	partial void Leave_unbound_type_name_part();

	// $ANTLR start "unbound_type_name_part"
	// cs.g:293:8: public unbound_type_name_part : '.' identifier ;
	[GrammarRule("unbound_type_name_part")]
	public csParser.unbound_type_name_part_return unbound_type_name_part()
	{
		Enter_unbound_type_name_part();
		EnterRule("unbound_type_name_part", 68);
		TraceIn("unbound_type_name_part", 68);
		csParser.unbound_type_name_part_return retval = new csParser.unbound_type_name_part_return();
		retval.Start = (IToken)input.LT(1);
		int unbound_type_name_part_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal266=null;
		csParser.identifier_return identifier267 = default(csParser.identifier_return);

		object char_literal266_tree=null;

		try { DebugEnterRule(GrammarFileName, "unbound_type_name_part");
		DebugLocation(293, 17);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 68)) { return retval; }
			// cs.g:293:30: ( '.' identifier )
			DebugEnterAlt(1);
			// cs.g:294:2: '.' identifier
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(294, 2);
			char_literal266=(IToken)Match(input,DOT,Follow._DOT_in_unbound_type_name_part2288); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal266_tree = (object)adaptor.Create(char_literal266);
			adaptor.AddChild(root_0, char_literal266_tree);
			}
			DebugLocation(294, 8);
			PushFollow(Follow._identifier_in_unbound_type_name_part2292);
			identifier267=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier267.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("unbound_type_name_part", 68);
			LeaveRule("unbound_type_name_part", 68);
			Leave_unbound_type_name_part();
			if (state.backtracking > 0) { Memoize(input, 68, unbound_type_name_part_StartIndex); }
		}
		DebugLocation(294, 17);
		} finally { DebugExitRule(GrammarFileName, "unbound_type_name_part"); }
		return retval;

	}
	// $ANTLR end "unbound_type_name_part"

	public class generic_dimension_specifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_generic_dimension_specifier();
	partial void Leave_generic_dimension_specifier();

	// $ANTLR start "generic_dimension_specifier"
	// cs.g:295:8: public generic_dimension_specifier : '<' ( commas )? '>' ;
	[GrammarRule("generic_dimension_specifier")]
	public csParser.generic_dimension_specifier_return generic_dimension_specifier()
	{
		Enter_generic_dimension_specifier();
		EnterRule("generic_dimension_specifier", 69);
		TraceIn("generic_dimension_specifier", 69);
		csParser.generic_dimension_specifier_return retval = new csParser.generic_dimension_specifier_return();
		retval.Start = (IToken)input.LT(1);
		int generic_dimension_specifier_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal268=null;
		IToken char_literal270=null;
		csParser.commas_return commas269 = default(csParser.commas_return);

		object char_literal268_tree=null;
		object char_literal270_tree=null;

		try { DebugEnterRule(GrammarFileName, "generic_dimension_specifier");
		DebugLocation(295, 21);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 69)) { return retval; }
			// cs.g:295:35: ( '<' ( commas )? '>' )
			DebugEnterAlt(1);
			// cs.g:296:2: '<' ( commas )? '>'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(296, 2);
			char_literal268=(IToken)Match(input,101,Follow._101_in_generic_dimension_specifier2302); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal268_tree = (object)adaptor.Create(char_literal268);
			adaptor.AddChild(root_0, char_literal268_tree);
			}
			DebugLocation(296, 8);
			// cs.g:296:8: ( commas )?
			int alt74=2;
			try { DebugEnterSubRule(74);
			try { DebugEnterDecision(74, decisionCanBacktrack[74]);
			int LA74_0 = input.LA(1);

			if ((LA74_0==91))
			{
				alt74=1;
			}
			} finally { DebugExitDecision(74); }
			switch (alt74)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:296:8: commas
				{
				DebugLocation(296, 8);
				PushFollow(Follow._commas_in_generic_dimension_specifier2306);
				commas269=commas();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, commas269.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(74); }

			DebugLocation(296, 18);
			char_literal270=(IToken)Match(input,GT,Follow._GT_in_generic_dimension_specifier2311); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal270_tree = (object)adaptor.Create(char_literal270);
			adaptor.AddChild(root_0, char_literal270_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("generic_dimension_specifier", 69);
			LeaveRule("generic_dimension_specifier", 69);
			Leave_generic_dimension_specifier();
			if (state.backtracking > 0) { Memoize(input, 69, generic_dimension_specifier_StartIndex); }
		}
		DebugLocation(296, 21);
		} finally { DebugExitRule(GrammarFileName, "generic_dimension_specifier"); }
		return retval;

	}
	// $ANTLR end "generic_dimension_specifier"

	public class commas_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_commas();
	partial void Leave_commas();

	// $ANTLR start "commas"
	// cs.g:297:8: public commas : ( ',' )+ ;
	[GrammarRule("commas")]
	public csParser.commas_return commas()
	{
		Enter_commas();
		EnterRule("commas", 70);
		TraceIn("commas", 70);
		csParser.commas_return retval = new csParser.commas_return();
		retval.Start = (IToken)input.LT(1);
		int commas_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal271=null;

		object char_literal271_tree=null;

		try { DebugEnterRule(GrammarFileName, "commas");
		DebugLocation(297, 6);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 70)) { return retval; }
			// cs.g:297:14: ( ( ',' )+ )
			DebugEnterAlt(1);
			// cs.g:298:2: ( ',' )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(298, 2);
			// cs.g:298:2: ( ',' )+
			int cnt75=0;
			try { DebugEnterSubRule(75);
			while (true)
			{
				int alt75=2;
				try { DebugEnterDecision(75, decisionCanBacktrack[75]);
				int LA75_0 = input.LA(1);

				if ((LA75_0==91))
				{
					alt75=1;
				}


				} finally { DebugExitDecision(75); }
				switch (alt75)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:298:2: ','
					{
					DebugLocation(298, 2);
					char_literal271=(IToken)Match(input,91,Follow._91_in_commas2322); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal271_tree = (object)adaptor.Create(char_literal271);
					adaptor.AddChild(root_0, char_literal271_tree);
					}

					}
					break;

				default:
					if (cnt75 >= 1)
						goto loop75;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee75 = new EarlyExitException( 75, input );
					DebugRecognitionException(eee75);
					throw eee75;
				}
				cnt75++;
			}
			loop75:
				;

			} finally { DebugExitSubRule(75); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("commas", 70);
			LeaveRule("commas", 70);
			Leave_commas();
			if (state.backtracking > 0) { Memoize(input, 70, commas_StartIndex); }
		}
		DebugLocation(298, 6);
		} finally { DebugExitRule(GrammarFileName, "commas"); }
		return retval;

	}
	// $ANTLR end "commas"

	public class type_name_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_type_name();
	partial void Leave_type_name();

	// $ANTLR start "type_name"
	// cs.g:304:8: public type_name : namespace_or_type_name ;
	[GrammarRule("type_name")]
	public csParser.type_name_return type_name()
	{
		Enter_type_name();
		EnterRule("type_name", 71);
		TraceIn("type_name", 71);
		csParser.type_name_return retval = new csParser.type_name_return();
		retval.Start = (IToken)input.LT(1);
		int type_name_StartIndex = input.Index;
		object root_0 = null;

		csParser.namespace_or_type_name_return namespace_or_type_name272 = default(csParser.namespace_or_type_name_return);


		try { DebugEnterRule(GrammarFileName, "type_name");
		DebugLocation(304, 24);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 71)) { return retval; }
			// cs.g:304:17: ( namespace_or_type_name )
			DebugEnterAlt(1);
			// cs.g:305:2: namespace_or_type_name
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(305, 2);
			PushFollow(Follow._namespace_or_type_name_in_type_name2340);
			namespace_or_type_name272=namespace_or_type_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_or_type_name272.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("type_name", 71);
			LeaveRule("type_name", 71);
			Leave_type_name();
			if (state.backtracking > 0) { Memoize(input, 71, type_name_StartIndex); }
		}
		DebugLocation(305, 24);
		} finally { DebugExitRule(GrammarFileName, "type_name"); }
		return retval;

	}
	// $ANTLR end "type_name"

	public class namespace_or_type_name_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_namespace_or_type_name();
	partial void Leave_namespace_or_type_name();

	// $ANTLR start "namespace_or_type_name"
	// cs.g:306:8: public namespace_or_type_name : type_or_generic ( '::' type_or_generic )? ( '.' type_or_generic )* ;
	[GrammarRule("namespace_or_type_name")]
	public csParser.namespace_or_type_name_return namespace_or_type_name()
	{
		Enter_namespace_or_type_name();
		EnterRule("namespace_or_type_name", 72);
		TraceIn("namespace_or_type_name", 72);
		csParser.namespace_or_type_name_return retval = new csParser.namespace_or_type_name_return();
		retval.Start = (IToken)input.LT(1);
		int namespace_or_type_name_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal274=null;
		IToken char_literal276=null;
		csParser.type_or_generic_return type_or_generic273 = default(csParser.type_or_generic_return);
		csParser.type_or_generic_return type_or_generic275 = default(csParser.type_or_generic_return);
		csParser.type_or_generic_return type_or_generic277 = default(csParser.type_or_generic_return);

		object string_literal274_tree=null;
		object char_literal276_tree=null;

		try { DebugEnterRule(GrammarFileName, "namespace_or_type_name");
		DebugLocation(306, 69);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 72)) { return retval; }
			// cs.g:306:30: ( type_or_generic ( '::' type_or_generic )? ( '.' type_or_generic )* )
			DebugEnterAlt(1);
			// cs.g:307:3: type_or_generic ( '::' type_or_generic )? ( '.' type_or_generic )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(307, 3);
			PushFollow(Follow._type_or_generic_in_namespace_or_type_name2351);
			type_or_generic273=type_or_generic();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic273.Tree);
			DebugLocation(307, 21);
			// cs.g:307:21: ( '::' type_or_generic )?
			int alt76=2;
			try { DebugEnterSubRule(76);
			try { DebugEnterDecision(76, decisionCanBacktrack[76]);
			int LA76_0 = input.LA(1);

			if ((LA76_0==85))
			{
				alt76=1;
			}
			} finally { DebugExitDecision(76); }
			switch (alt76)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:307:22: '::' type_or_generic
				{
				DebugLocation(307, 22);
				string_literal274=(IToken)Match(input,85,Follow._85_in_namespace_or_type_name2356); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal274_tree = (object)adaptor.Create(string_literal274);
				adaptor.AddChild(root_0, string_literal274_tree);
				}
				DebugLocation(307, 27);
				PushFollow(Follow._type_or_generic_in_namespace_or_type_name2358);
				type_or_generic275=type_or_generic();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic275.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(76); }

			DebugLocation(307, 45);
			// cs.g:307:45: ( '.' type_or_generic )*
			try { DebugEnterSubRule(77);
			while (true)
			{
				int alt77=2;
				try { DebugEnterDecision(77, decisionCanBacktrack[77]);
				int LA77_0 = input.LA(1);

				if ((LA77_0==DOT))
				{
					int LA77_2 = input.LA(2);

					if ((LA77_2==IDENTIFIER||(LA77_2>=ELIF && LA77_2<=UNDEF)||LA77_2==65||(LA77_2>=132 && LA77_2<=133)||(LA77_2>=135 && LA77_2<=148)||(LA77_2>=150 && LA77_2<=152)||LA77_2==154||(LA77_2>=156 && LA77_2<=159)||LA77_2==170||(LA77_2>=177 && LA77_2<=178)||LA77_2==195||LA77_2==202))
					{
						alt77=1;
					}


				}


				} finally { DebugExitDecision(77); }
				switch ( alt77 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:307:46: '.' type_or_generic
					{
					DebugLocation(307, 46);
					char_literal276=(IToken)Match(input,DOT,Follow._DOT_in_namespace_or_type_name2363); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal276_tree = (object)adaptor.Create(char_literal276);
					adaptor.AddChild(root_0, char_literal276_tree);
					}
					DebugLocation(307, 52);
					PushFollow(Follow._type_or_generic_in_namespace_or_type_name2367);
					type_or_generic277=type_or_generic();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic277.Tree);

					}
					break;

				default:
					goto loop77;
				}
			}

			loop77:
				;

			} finally { DebugExitSubRule(77); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("namespace_or_type_name", 72);
			LeaveRule("namespace_or_type_name", 72);
			Leave_namespace_or_type_name();
			if (state.backtracking > 0) { Memoize(input, 72, namespace_or_type_name_StartIndex); }
		}
		DebugLocation(307, 69);
		} finally { DebugExitRule(GrammarFileName, "namespace_or_type_name"); }
		return retval;

	}
	// $ANTLR end "namespace_or_type_name"

	public class type_or_generic_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_type_or_generic();
	partial void Leave_type_or_generic();

	// $ANTLR start "type_or_generic"
	// cs.g:308:8: public type_or_generic : ( ( identifier generic_argument_list )=> identifier generic_argument_list | identifier );
	[GrammarRule("type_or_generic")]
	public csParser.type_or_generic_return type_or_generic()
	{
		Enter_type_or_generic();
		EnterRule("type_or_generic", 73);
		TraceIn("type_or_generic", 73);
		csParser.type_or_generic_return retval = new csParser.type_or_generic_return();
		retval.Start = (IToken)input.LT(1);
		int type_or_generic_StartIndex = input.Index;
		object root_0 = null;

		csParser.identifier_return identifier278 = default(csParser.identifier_return);
		csParser.generic_argument_list_return generic_argument_list279 = default(csParser.generic_argument_list_return);
		csParser.identifier_return identifier280 = default(csParser.identifier_return);


		try { DebugEnterRule(GrammarFileName, "type_or_generic");
		DebugLocation(308, 14);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 73)) { return retval; }
			// cs.g:308:23: ( ( identifier generic_argument_list )=> identifier generic_argument_list | identifier )
			int alt78=2;
			try { DebugEnterDecision(78, decisionCanBacktrack[78]);
			int LA78_0 = input.LA(1);

			if ((LA78_0==IDENTIFIER))
			{
				int LA78_1 = input.LA(2);

				if ((EvaluatePredicate(synpred15_cs_fragment)))
				{
					alt78=1;
				}
				else if ((true))
				{
					alt78=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 78, 1, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}
			else if (((LA78_0>=ELIF && LA78_0<=UNDEF)||LA78_0==65||(LA78_0>=132 && LA78_0<=133)||(LA78_0>=135 && LA78_0<=148)||(LA78_0>=150 && LA78_0<=152)||LA78_0==154||(LA78_0>=156 && LA78_0<=159)||LA78_0==170||(LA78_0>=177 && LA78_0<=178)||LA78_0==195||LA78_0==202))
			{
				int LA78_2 = input.LA(2);

				if ((EvaluatePredicate(synpred15_cs_fragment)))
				{
					alt78=1;
				}
				else if ((true))
				{
					alt78=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 78, 2, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 78, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(78); }
			switch (alt78)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:309:2: ( identifier generic_argument_list )=> identifier generic_argument_list
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(309, 42);
				PushFollow(Follow._identifier_in_type_or_generic2389);
				identifier278=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier278.Tree);
				DebugLocation(309, 55);
				PushFollow(Follow._generic_argument_list_in_type_or_generic2393);
				generic_argument_list279=generic_argument_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_argument_list279.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:310:4: identifier
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(310, 4);
				PushFollow(Follow._identifier_in_type_or_generic2398);
				identifier280=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier280.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("type_or_generic", 73);
			LeaveRule("type_or_generic", 73);
			Leave_type_or_generic();
			if (state.backtracking > 0) { Memoize(input, 73, type_or_generic_StartIndex); }
		}
		DebugLocation(310, 14);
		} finally { DebugExitRule(GrammarFileName, "type_or_generic"); }
		return retval;

	}
	// $ANTLR end "type_or_generic"

	public class qid_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_qid();
	partial void Leave_qid();

	// $ANTLR start "qid"
	// cs.g:312:8: public qid : qid_start ( qid_part )* ;
	[GrammarRule("qid")]
	public csParser.qid_return qid()
	{
		Enter_qid();
		EnterRule("qid", 74);
		TraceIn("qid", 74);
		csParser.qid_return retval = new csParser.qid_return();
		retval.Start = (IToken)input.LT(1);
		int qid_StartIndex = input.Index;
		object root_0 = null;

		csParser.qid_start_return qid_start281 = default(csParser.qid_start_return);
		csParser.qid_part_return qid_part282 = default(csParser.qid_part_return);


		try { DebugEnterRule(GrammarFileName, "qid");
		DebugLocation(312, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 74)) { return retval; }
			// cs.g:312:11: ( qid_start ( qid_part )* )
			DebugEnterAlt(1);
			// cs.g:313:2: qid_start ( qid_part )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(313, 2);
			PushFollow(Follow._qid_start_in_qid2411);
			qid_start281=qid_start();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, qid_start281.Tree);
			DebugLocation(313, 14);
			// cs.g:313:14: ( qid_part )*
			try { DebugEnterSubRule(79);
			while (true)
			{
				int alt79=2;
				try { DebugEnterDecision(79, decisionCanBacktrack[79]);
				int LA79_0 = input.LA(1);

				if ((LA79_0==DOT))
				{
					int LA79_2 = input.LA(2);

					if ((LA79_2==IDENTIFIER||(LA79_2>=ELIF && LA79_2<=UNDEF)||LA79_2==65||(LA79_2>=132 && LA79_2<=133)||(LA79_2>=135 && LA79_2<=148)||(LA79_2>=150 && LA79_2<=152)||LA79_2==154||(LA79_2>=156 && LA79_2<=159)||LA79_2==170||(LA79_2>=177 && LA79_2<=178)||LA79_2==195||LA79_2==202))
					{
						alt79=1;
					}


				}
				else if ((LA79_0==PTR))
				{
					alt79=1;
				}


				} finally { DebugExitDecision(79); }
				switch ( alt79 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:313:14: qid_part
					{
					DebugLocation(313, 14);
					PushFollow(Follow._qid_part_in_qid2415);
					qid_part282=qid_part();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, qid_part282.Tree);

					}
					break;

				default:
					goto loop79;
				}
			}

			loop79:
				;

			} finally { DebugExitSubRule(79); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("qid", 74);
			LeaveRule("qid", 74);
			Leave_qid();
			if (state.backtracking > 0) { Memoize(input, 74, qid_StartIndex); }
		}
		DebugLocation(314, 1);
		} finally { DebugExitRule(GrammarFileName, "qid"); }
		return retval;

	}
	// $ANTLR end "qid"

	public class qid_start_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_qid_start();
	partial void Leave_qid_start();

	// $ANTLR start "qid_start"
	// cs.g:315:8: public qid_start : ( predefined_type | ( identifier generic_argument_list )=> identifier generic_argument_list | identifier ( '::' identifier )? | literal );
	[GrammarRule("qid_start")]
	public csParser.qid_start_return qid_start()
	{
		Enter_qid_start();
		EnterRule("qid_start", 75);
		TraceIn("qid_start", 75);
		csParser.qid_start_return retval = new csParser.qid_start_return();
		retval.Start = (IToken)input.LT(1);
		int qid_start_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal287=null;
		csParser.predefined_type_return predefined_type283 = default(csParser.predefined_type_return);
		csParser.identifier_return identifier284 = default(csParser.identifier_return);
		csParser.generic_argument_list_return generic_argument_list285 = default(csParser.generic_argument_list_return);
		csParser.identifier_return identifier286 = default(csParser.identifier_return);
		csParser.identifier_return identifier288 = default(csParser.identifier_return);
		csParser.literal_return literal289 = default(csParser.literal_return);

		object string_literal287_tree=null;

		try { DebugEnterRule(GrammarFileName, "qid_start");
		DebugLocation(315, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 75)) { return retval; }
			// cs.g:315:17: ( predefined_type | ( identifier generic_argument_list )=> identifier generic_argument_list | identifier ( '::' identifier )? | literal )
			int alt81=4;
			try { DebugEnterDecision(81, decisionCanBacktrack[81]);
			switch (input.LA(1))
			{
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 196:
			case 197:
			case 198:
			case 199:
			case 200:
			case 201:
				{
				alt81=1;
				}
				break;
			case IDENTIFIER:
				{
				int LA81_2 = input.LA(2);

				if ((LA81_2==101) && (EvaluatePredicate(synpred16_cs_fragment)))
				{
					alt81=2;
				}
				else if (((LA81_2>=DOT && LA81_2<=PTR)||(LA81_2>=62 && LA81_2<=63)||LA81_2==66||LA81_2==85||(LA81_2>=90 && LA81_2<=91)))
				{
					alt81=3;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 81, 2, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 132:
			case 133:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 170:
			case 177:
			case 178:
			case 195:
			case 202:
				{
				int LA81_3 = input.LA(2);

				if ((LA81_3==101) && (EvaluatePredicate(synpred16_cs_fragment)))
				{
					alt81=2;
				}
				else if (((LA81_3>=DOT && LA81_3<=PTR)||(LA81_3>=62 && LA81_3<=63)||LA81_3==66||LA81_3==85||(LA81_3>=90 && LA81_3<=91)))
				{
					alt81=3;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 81, 3, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case Real_literal:
			case NUMBER:
			case Hex_number:
			case Character_literal:
			case STRINGLITERAL:
			case Verbatim_string_literal:
			case TRUE:
			case FALSE:
			case NULL:
				{
				alt81=4;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 81, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(81); }
			switch (alt81)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:316:2: predefined_type
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(316, 2);
				PushFollow(Follow._predefined_type_in_qid_start2427);
				predefined_type283=predefined_type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type283.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:317:4: ( identifier generic_argument_list )=> identifier generic_argument_list
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(317, 44);
				PushFollow(Follow._identifier_in_qid_start2442);
				identifier284=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier284.Tree);
				DebugLocation(317, 57);
				PushFollow(Follow._generic_argument_list_in_qid_start2446);
				generic_argument_list285=generic_argument_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_argument_list285.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:320:4: identifier ( '::' identifier )?
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(320, 4);
				PushFollow(Follow._identifier_in_qid_start2453);
				identifier286=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier286.Tree);
				DebugLocation(320, 17);
				// cs.g:320:17: ( '::' identifier )?
				int alt80=2;
				try { DebugEnterSubRule(80);
				try { DebugEnterDecision(80, decisionCanBacktrack[80]);
				int LA80_0 = input.LA(1);

				if ((LA80_0==85))
				{
					alt80=1;
				}
				} finally { DebugExitDecision(80); }
				switch (alt80)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:320:18: '::' identifier
					{
					DebugLocation(320, 18);
					string_literal287=(IToken)Match(input,85,Follow._85_in_qid_start2458); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					string_literal287_tree = (object)adaptor.Create(string_literal287);
					adaptor.AddChild(root_0, string_literal287_tree);
					}
					DebugLocation(320, 25);
					PushFollow(Follow._identifier_in_qid_start2462);
					identifier288=identifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier288.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(80); }


				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:321:4: literal
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(321, 4);
				PushFollow(Follow._literal_in_qid_start2469);
				literal289=literal();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, literal289.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("qid_start", 75);
			LeaveRule("qid_start", 75);
			Leave_qid_start();
			if (state.backtracking > 0) { Memoize(input, 75, qid_start_StartIndex); }
		}
		DebugLocation(322, 1);
		} finally { DebugExitRule(GrammarFileName, "qid_start"); }
		return retval;

	}
	// $ANTLR end "qid_start"

	public class qid_part_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_qid_part();
	partial void Leave_qid_part();

	// $ANTLR start "qid_part"
	// cs.g:325:8: public qid_part : access_identifier ;
	[GrammarRule("qid_part")]
	public csParser.qid_part_return qid_part()
	{
		Enter_qid_part();
		EnterRule("qid_part", 76);
		TraceIn("qid_part", 76);
		csParser.qid_part_return retval = new csParser.qid_part_return();
		retval.Start = (IToken)input.LT(1);
		int qid_part_StartIndex = input.Index;
		object root_0 = null;

		csParser.access_identifier_return access_identifier290 = default(csParser.access_identifier_return);


		try { DebugEnterRule(GrammarFileName, "qid_part");
		DebugLocation(325, 19);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 76)) { return retval; }
			// cs.g:325:16: ( access_identifier )
			DebugEnterAlt(1);
			// cs.g:326:2: access_identifier
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(326, 2);
			PushFollow(Follow._access_identifier_in_qid_part2485);
			access_identifier290=access_identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, access_identifier290.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("qid_part", 76);
			LeaveRule("qid_part", 76);
			Leave_qid_part();
			if (state.backtracking > 0) { Memoize(input, 76, qid_part_StartIndex); }
		}
		DebugLocation(326, 19);
		} finally { DebugExitRule(GrammarFileName, "qid_part"); }
		return retval;

	}
	// $ANTLR end "qid_part"

	public class generic_argument_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_generic_argument_list();
	partial void Leave_generic_argument_list();

	// $ANTLR start "generic_argument_list"
	// cs.g:328:8: public generic_argument_list : '<' type_arguments '>' ;
	[GrammarRule("generic_argument_list")]
	public csParser.generic_argument_list_return generic_argument_list()
	{
		Enter_generic_argument_list();
		EnterRule("generic_argument_list", 77);
		TraceIn("generic_argument_list", 77);
		csParser.generic_argument_list_return retval = new csParser.generic_argument_list_return();
		retval.Start = (IToken)input.LT(1);
		int generic_argument_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal291=null;
		IToken char_literal293=null;
		csParser.type_arguments_return type_arguments292 = default(csParser.type_arguments_return);

		object char_literal291_tree=null;
		object char_literal293_tree=null;

		try { DebugEnterRule(GrammarFileName, "generic_argument_list");
		DebugLocation(328, 28);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 77)) { return retval; }
			// cs.g:328:29: ( '<' type_arguments '>' )
			DebugEnterAlt(1);
			// cs.g:329:2: '<' type_arguments '>'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(329, 2);
			char_literal291=(IToken)Match(input,101,Follow._101_in_generic_argument_list2497); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal291_tree = (object)adaptor.Create(char_literal291);
			adaptor.AddChild(root_0, char_literal291_tree);
			}
			DebugLocation(329, 8);
			PushFollow(Follow._type_arguments_in_generic_argument_list2501);
			type_arguments292=type_arguments();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_arguments292.Tree);
			DebugLocation(329, 25);
			char_literal293=(IToken)Match(input,GT,Follow._GT_in_generic_argument_list2505); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal293_tree = (object)adaptor.Create(char_literal293);
			adaptor.AddChild(root_0, char_literal293_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("generic_argument_list", 77);
			LeaveRule("generic_argument_list", 77);
			Leave_generic_argument_list();
			if (state.backtracking > 0) { Memoize(input, 77, generic_argument_list_StartIndex); }
		}
		DebugLocation(329, 28);
		} finally { DebugExitRule(GrammarFileName, "generic_argument_list"); }
		return retval;

	}
	// $ANTLR end "generic_argument_list"

	public class type_arguments_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_type_arguments();
	partial void Leave_type_arguments();

	// $ANTLR start "type_arguments"
	// cs.g:330:8: public type_arguments : type ( ',' type )* ;
	[GrammarRule("type_arguments")]
	public csParser.type_arguments_return type_arguments()
	{
		Enter_type_arguments();
		EnterRule("type_arguments", 78);
		TraceIn("type_arguments", 78);
		csParser.type_arguments_return retval = new csParser.type_arguments_return();
		retval.Start = (IToken)input.LT(1);
		int type_arguments_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal295=null;
		csParser.type_return type294 = default(csParser.type_return);
		csParser.type_return type296 = default(csParser.type_return);

		object char_literal295_tree=null;

		try { DebugEnterRule(GrammarFileName, "type_arguments");
		DebugLocation(330, 18);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 78)) { return retval; }
			// cs.g:330:22: ( type ( ',' type )* )
			DebugEnterAlt(1);
			// cs.g:331:2: type ( ',' type )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(331, 2);
			PushFollow(Follow._type_in_type_arguments2516);
			type294=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type294.Tree);
			DebugLocation(331, 7);
			// cs.g:331:7: ( ',' type )*
			try { DebugEnterSubRule(82);
			while (true)
			{
				int alt82=2;
				try { DebugEnterDecision(82, decisionCanBacktrack[82]);
				int LA82_0 = input.LA(1);

				if ((LA82_0==91))
				{
					alt82=1;
				}


				} finally { DebugExitDecision(82); }
				switch ( alt82 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:331:8: ',' type
					{
					DebugLocation(331, 8);
					char_literal295=(IToken)Match(input,91,Follow._91_in_type_arguments2519); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal295_tree = (object)adaptor.Create(char_literal295);
					adaptor.AddChild(root_0, char_literal295_tree);
					}
					DebugLocation(331, 12);
					PushFollow(Follow._type_in_type_arguments2521);
					type296=type();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type296.Tree);

					}
					break;

				default:
					goto loop82;
				}
			}

			loop82:
				;

			} finally { DebugExitSubRule(82); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("type_arguments", 78);
			LeaveRule("type_arguments", 78);
			Leave_type_arguments();
			if (state.backtracking > 0) { Memoize(input, 78, type_arguments_StartIndex); }
		}
		DebugLocation(331, 18);
		} finally { DebugExitRule(GrammarFileName, "type_arguments"); }
		return retval;

	}
	// $ANTLR end "type_arguments"

	public class type_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_type();
	partial void Leave_type();

	// $ANTLR start "type"
	// cs.g:333:8: public type : ( ( ( predefined_type | type_name ) rank_specifiers )=> ( predefined_type | type_name ) rank_specifiers ( '*' )* | ( ( predefined_type | type_name ) ( ( '*' )+ | '?' ) )=> ( predefined_type | type_name ) ( ( '*' )+ | '?' ) | ( predefined_type | type_name ) | 'void' ( '*' )+ );
	[GrammarRule("type")]
	public csParser.type_return type()
	{
		Enter_type();
		EnterRule("type", 79);
		TraceIn("type", 79);
		csParser.type_return retval = new csParser.type_return();
		retval.Start = (IToken)input.LT(1);
		int type_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal300=null;
		IToken char_literal303=null;
		IToken char_literal304=null;
		IToken string_literal307=null;
		IToken char_literal308=null;
		csParser.predefined_type_return predefined_type297 = default(csParser.predefined_type_return);
		csParser.type_name_return type_name298 = default(csParser.type_name_return);
		csParser.rank_specifiers_return rank_specifiers299 = default(csParser.rank_specifiers_return);
		csParser.predefined_type_return predefined_type301 = default(csParser.predefined_type_return);
		csParser.type_name_return type_name302 = default(csParser.type_name_return);
		csParser.predefined_type_return predefined_type305 = default(csParser.predefined_type_return);
		csParser.type_name_return type_name306 = default(csParser.type_name_return);

		object char_literal300_tree=null;
		object char_literal303_tree=null;
		object char_literal304_tree=null;
		object string_literal307_tree=null;
		object char_literal308_tree=null;

		try { DebugEnterRule(GrammarFileName, "type");
		DebugLocation(333, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 79)) { return retval; }
			// cs.g:333:12: ( ( ( predefined_type | type_name ) rank_specifiers )=> ( predefined_type | type_name ) rank_specifiers ( '*' )* | ( ( predefined_type | type_name ) ( ( '*' )+ | '?' ) )=> ( predefined_type | type_name ) ( ( '*' )+ | '?' ) | ( predefined_type | type_name ) | 'void' ( '*' )+ )
			int alt90=4;
			try { DebugEnterDecision(90, decisionCanBacktrack[90]);
			switch (input.LA(1))
			{
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 196:
			case 197:
			case 198:
			case 199:
			case 200:
			case 201:
				{
				int LA90_1 = input.LA(2);

				if ((EvaluatePredicate(synpred17_cs_fragment)))
				{
					alt90=1;
				}
				else if ((EvaluatePredicate(synpred18_cs_fragment)))
				{
					alt90=2;
				}
				else if ((true))
				{
					alt90=3;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 90, 1, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case IDENTIFIER:
				{
				int LA90_2 = input.LA(2);

				if ((EvaluatePredicate(synpred17_cs_fragment)))
				{
					alt90=1;
				}
				else if ((EvaluatePredicate(synpred18_cs_fragment)))
				{
					alt90=2;
				}
				else if ((true))
				{
					alt90=3;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 90, 2, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 132:
			case 133:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 170:
			case 177:
			case 178:
			case 195:
			case 202:
				{
				int LA90_3 = input.LA(2);

				if ((EvaluatePredicate(synpred17_cs_fragment)))
				{
					alt90=1;
				}
				else if ((EvaluatePredicate(synpred18_cs_fragment)))
				{
					alt90=2;
				}
				else if ((true))
				{
					alt90=3;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 90, 3, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case 82:
				{
				alt90=4;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 90, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(90); }
			switch (alt90)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:334:4: ( ( predefined_type | type_name ) rank_specifiers )=> ( predefined_type | type_name ) rank_specifiers ( '*' )*
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(334, 56);
				// cs.g:334:56: ( predefined_type | type_name )
				int alt83=2;
				try { DebugEnterSubRule(83);
				try { DebugEnterDecision(83, decisionCanBacktrack[83]);
				int LA83_0 = input.LA(1);

				if (((LA83_0>=160 && LA83_0<=168)||(LA83_0>=196 && LA83_0<=201)))
				{
					alt83=1;
				}
				else if ((LA83_0==IDENTIFIER||(LA83_0>=ELIF && LA83_0<=UNDEF)||LA83_0==65||(LA83_0>=132 && LA83_0<=133)||(LA83_0>=135 && LA83_0<=148)||(LA83_0>=150 && LA83_0<=152)||LA83_0==154||(LA83_0>=156 && LA83_0<=159)||LA83_0==170||(LA83_0>=177 && LA83_0<=178)||LA83_0==195||LA83_0==202))
				{
					alt83=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 83, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				} finally { DebugExitDecision(83); }
				switch (alt83)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:334:57: predefined_type
					{
					DebugLocation(334, 57);
					PushFollow(Follow._predefined_type_in_type2552);
					predefined_type297=predefined_type();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type297.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:334:75: type_name
					{
					DebugLocation(334, 75);
					PushFollow(Follow._type_name_in_type2556);
					type_name298=type_name();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name298.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(83); }

				DebugLocation(334, 88);
				PushFollow(Follow._rank_specifiers_in_type2561);
				rank_specifiers299=rank_specifiers();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, rank_specifiers299.Tree);
				DebugLocation(334, 106);
				// cs.g:334:106: ( '*' )*
				try { DebugEnterSubRule(84);
				while (true)
				{
					int alt84=2;
					try { DebugEnterDecision(84, decisionCanBacktrack[84]);
					int LA84_0 = input.LA(1);

					if ((LA84_0==102))
					{
						alt84=1;
					}


					} finally { DebugExitDecision(84); }
					switch ( alt84 )
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:334:106: '*'
						{
						DebugLocation(334, 106);
						char_literal300=(IToken)Match(input,102,Follow._102_in_type2565); if (state.failed) return retval;
						if ( state.backtracking==0 ) {
						char_literal300_tree = (object)adaptor.Create(char_literal300);
						adaptor.AddChild(root_0, char_literal300_tree);
						}

						}
						break;

					default:
						goto loop84;
					}
				}

				loop84:
					;

				} finally { DebugExitSubRule(84); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:335:4: ( ( predefined_type | type_name ) ( ( '*' )+ | '?' ) )=> ( predefined_type | type_name ) ( ( '*' )+ | '?' )
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(335, 53);
				// cs.g:335:53: ( predefined_type | type_name )
				int alt85=2;
				try { DebugEnterSubRule(85);
				try { DebugEnterDecision(85, decisionCanBacktrack[85]);
				int LA85_0 = input.LA(1);

				if (((LA85_0>=160 && LA85_0<=168)||(LA85_0>=196 && LA85_0<=201)))
				{
					alt85=1;
				}
				else if ((LA85_0==IDENTIFIER||(LA85_0>=ELIF && LA85_0<=UNDEF)||LA85_0==65||(LA85_0>=132 && LA85_0<=133)||(LA85_0>=135 && LA85_0<=148)||(LA85_0>=150 && LA85_0<=152)||LA85_0==154||(LA85_0>=156 && LA85_0<=159)||LA85_0==170||(LA85_0>=177 && LA85_0<=178)||LA85_0==195||LA85_0==202))
				{
					alt85=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 85, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				} finally { DebugExitDecision(85); }
				switch (alt85)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:335:54: predefined_type
					{
					DebugLocation(335, 54);
					PushFollow(Follow._predefined_type_in_type2594);
					predefined_type301=predefined_type();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type301.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:335:72: type_name
					{
					DebugLocation(335, 72);
					PushFollow(Follow._type_name_in_type2598);
					type_name302=type_name();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name302.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(85); }

				DebugLocation(335, 85);
				// cs.g:335:85: ( ( '*' )+ | '?' )
				int alt87=2;
				try { DebugEnterSubRule(87);
				try { DebugEnterDecision(87, decisionCanBacktrack[87]);
				int LA87_0 = input.LA(1);

				if ((LA87_0==102))
				{
					alt87=1;
				}
				else if ((LA87_0==103))
				{
					alt87=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 87, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				} finally { DebugExitDecision(87); }
				switch (alt87)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:335:86: ( '*' )+
					{
					DebugLocation(335, 86);
					// cs.g:335:86: ( '*' )+
					int cnt86=0;
					try { DebugEnterSubRule(86);
					while (true)
					{
						int alt86=2;
						try { DebugEnterDecision(86, decisionCanBacktrack[86]);
						int LA86_0 = input.LA(1);

						if ((LA86_0==102))
						{
							alt86=1;
						}


						} finally { DebugExitDecision(86); }
						switch (alt86)
						{
						case 1:
							DebugEnterAlt(1);
							// cs.g:335:86: '*'
							{
							DebugLocation(335, 86);
							char_literal303=(IToken)Match(input,102,Follow._102_in_type2604); if (state.failed) return retval;
							if ( state.backtracking==0 ) {
							char_literal303_tree = (object)adaptor.Create(char_literal303);
							adaptor.AddChild(root_0, char_literal303_tree);
							}

							}
							break;

						default:
							if (cnt86 >= 1)
								goto loop86;

							if (state.backtracking>0) {state.failed=true; return retval;}
							EarlyExitException eee86 = new EarlyExitException( 86, input );
							DebugRecognitionException(eee86);
							throw eee86;
						}
						cnt86++;
					}
					loop86:
						;

					} finally { DebugExitSubRule(86); }


					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:335:93: '?'
					{
					DebugLocation(335, 93);
					char_literal304=(IToken)Match(input,103,Follow._103_in_type2609); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal304_tree = (object)adaptor.Create(char_literal304);
					adaptor.AddChild(root_0, char_literal304_tree);
					}

					}
					break;

				}
				} finally { DebugExitSubRule(87); }


				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:336:4: ( predefined_type | type_name )
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(336, 4);
				// cs.g:336:4: ( predefined_type | type_name )
				int alt88=2;
				try { DebugEnterSubRule(88);
				try { DebugEnterDecision(88, decisionCanBacktrack[88]);
				int LA88_0 = input.LA(1);

				if (((LA88_0>=160 && LA88_0<=168)||(LA88_0>=196 && LA88_0<=201)))
				{
					alt88=1;
				}
				else if ((LA88_0==IDENTIFIER||(LA88_0>=ELIF && LA88_0<=UNDEF)||LA88_0==65||(LA88_0>=132 && LA88_0<=133)||(LA88_0>=135 && LA88_0<=148)||(LA88_0>=150 && LA88_0<=152)||LA88_0==154||(LA88_0>=156 && LA88_0<=159)||LA88_0==170||(LA88_0>=177 && LA88_0<=178)||LA88_0==195||LA88_0==202))
				{
					alt88=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 88, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				} finally { DebugExitDecision(88); }
				switch (alt88)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:336:5: predefined_type
					{
					DebugLocation(336, 5);
					PushFollow(Follow._predefined_type_in_type2616);
					predefined_type305=predefined_type();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type305.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:336:23: type_name
					{
					DebugLocation(336, 23);
					PushFollow(Follow._type_name_in_type2620);
					type_name306=type_name();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name306.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(88); }


				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:337:4: 'void' ( '*' )+
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(337, 4);
				string_literal307=(IToken)Match(input,82,Follow._82_in_type2626); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal307_tree = (object)adaptor.Create(string_literal307);
				adaptor.AddChild(root_0, string_literal307_tree);
				}
				DebugLocation(337, 11);
				// cs.g:337:11: ( '*' )+
				int cnt89=0;
				try { DebugEnterSubRule(89);
				while (true)
				{
					int alt89=2;
					try { DebugEnterDecision(89, decisionCanBacktrack[89]);
					int LA89_0 = input.LA(1);

					if ((LA89_0==102))
					{
						alt89=1;
					}


					} finally { DebugExitDecision(89); }
					switch (alt89)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:337:11: '*'
						{
						DebugLocation(337, 11);
						char_literal308=(IToken)Match(input,102,Follow._102_in_type2628); if (state.failed) return retval;
						if ( state.backtracking==0 ) {
						char_literal308_tree = (object)adaptor.Create(char_literal308);
						adaptor.AddChild(root_0, char_literal308_tree);
						}

						}
						break;

					default:
						if (cnt89 >= 1)
							goto loop89;

						if (state.backtracking>0) {state.failed=true; return retval;}
						EarlyExitException eee89 = new EarlyExitException( 89, input );
						DebugRecognitionException(eee89);
						throw eee89;
					}
					cnt89++;
				}
				loop89:
					;

				} finally { DebugExitSubRule(89); }


				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("type", 79);
			LeaveRule("type", 79);
			Leave_type();
			if (state.backtracking > 0) { Memoize(input, 79, type_StartIndex); }
		}
		DebugLocation(338, 1);
		} finally { DebugExitRule(GrammarFileName, "type"); }
		return retval;

	}
	// $ANTLR end "type"

	public class non_nullable_type_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_non_nullable_type();
	partial void Leave_non_nullable_type();

	// $ANTLR start "non_nullable_type"
	// cs.g:339:8: public non_nullable_type : ( ( predefined_type | type_name ) ( rank_specifiers ( '*' )* | ( ( '*' )+ )? ) | 'void' ( '*' )+ );
	[GrammarRule("non_nullable_type")]
	public csParser.non_nullable_type_return non_nullable_type()
	{
		Enter_non_nullable_type();
		EnterRule("non_nullable_type", 80);
		TraceIn("non_nullable_type", 80);
		csParser.non_nullable_type_return retval = new csParser.non_nullable_type_return();
		retval.Start = (IToken)input.LT(1);
		int non_nullable_type_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal312=null;
		IToken char_literal313=null;
		IToken string_literal314=null;
		IToken char_literal315=null;
		csParser.predefined_type_return predefined_type309 = default(csParser.predefined_type_return);
		csParser.type_name_return type_name310 = default(csParser.type_name_return);
		csParser.rank_specifiers_return rank_specifiers311 = default(csParser.rank_specifiers_return);

		object char_literal312_tree=null;
		object char_literal313_tree=null;
		object string_literal314_tree=null;
		object char_literal315_tree=null;

		try { DebugEnterRule(GrammarFileName, "non_nullable_type");
		DebugLocation(339, 17);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 80)) { return retval; }
			// cs.g:339:25: ( ( predefined_type | type_name ) ( rank_specifiers ( '*' )* | ( ( '*' )+ )? ) | 'void' ( '*' )+ )
			int alt97=2;
			try { DebugEnterDecision(97, decisionCanBacktrack[97]);
			int LA97_0 = input.LA(1);

			if ((LA97_0==IDENTIFIER||(LA97_0>=ELIF && LA97_0<=UNDEF)||LA97_0==65||(LA97_0>=132 && LA97_0<=133)||(LA97_0>=135 && LA97_0<=148)||(LA97_0>=150 && LA97_0<=152)||LA97_0==154||(LA97_0>=156 && LA97_0<=168)||LA97_0==170||(LA97_0>=177 && LA97_0<=178)||(LA97_0>=195 && LA97_0<=202)))
			{
				alt97=1;
			}
			else if ((LA97_0==82))
			{
				alt97=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 97, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(97); }
			switch (alt97)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:340:2: ( predefined_type | type_name ) ( rank_specifiers ( '*' )* | ( ( '*' )+ )? )
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(340, 2);
				// cs.g:340:2: ( predefined_type | type_name )
				int alt91=2;
				try { DebugEnterSubRule(91);
				try { DebugEnterDecision(91, decisionCanBacktrack[91]);
				int LA91_0 = input.LA(1);

				if (((LA91_0>=160 && LA91_0<=168)||(LA91_0>=196 && LA91_0<=201)))
				{
					alt91=1;
				}
				else if ((LA91_0==IDENTIFIER||(LA91_0>=ELIF && LA91_0<=UNDEF)||LA91_0==65||(LA91_0>=132 && LA91_0<=133)||(LA91_0>=135 && LA91_0<=148)||(LA91_0>=150 && LA91_0<=152)||LA91_0==154||(LA91_0>=156 && LA91_0<=159)||LA91_0==170||(LA91_0>=177 && LA91_0<=178)||LA91_0==195||LA91_0==202))
				{
					alt91=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 91, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				} finally { DebugExitDecision(91); }
				switch (alt91)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:340:3: predefined_type
					{
					DebugLocation(340, 3);
					PushFollow(Follow._predefined_type_in_non_nullable_type2641);
					predefined_type309=predefined_type();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type309.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:340:21: type_name
					{
					DebugLocation(340, 21);
					PushFollow(Follow._type_name_in_non_nullable_type2645);
					type_name310=type_name();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name310.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(91); }

				DebugLocation(341, 3);
				// cs.g:341:3: ( rank_specifiers ( '*' )* | ( ( '*' )+ )? )
				int alt95=2;
				try { DebugEnterSubRule(95);
				try { DebugEnterDecision(95, decisionCanBacktrack[95]);
				int LA95_0 = input.LA(1);

				if ((LA95_0==88))
				{
					alt95=1;
				}
				else if ((LA95_0==EOF||LA95_0==IDENTIFIER||LA95_0==GT||(LA95_0>=ELIF && LA95_0<=RPAREN)||LA95_0==63||LA95_0==65||LA95_0==89||(LA95_0>=91 && LA95_0<=92)||(LA95_0>=101 && LA95_0<=103)||(LA95_0>=116 && LA95_0<=117)||(LA95_0>=121 && LA95_0<=130)||(LA95_0>=132 && LA95_0<=133)||(LA95_0>=135 && LA95_0<=148)||(LA95_0>=150 && LA95_0<=152)||LA95_0==154||(LA95_0>=156 && LA95_0<=159)||LA95_0==170||(LA95_0>=177 && LA95_0<=178)||LA95_0==195||LA95_0==202))
				{
					alt95=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 95, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				} finally { DebugExitDecision(95); }
				switch (alt95)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:341:7: rank_specifiers ( '*' )*
					{
					DebugLocation(341, 7);
					PushFollow(Follow._rank_specifiers_in_non_nullable_type2654);
					rank_specifiers311=rank_specifiers();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, rank_specifiers311.Tree);
					DebugLocation(341, 25);
					// cs.g:341:25: ( '*' )*
					try { DebugEnterSubRule(92);
					while (true)
					{
						int alt92=2;
						try { DebugEnterDecision(92, decisionCanBacktrack[92]);
						int LA92_0 = input.LA(1);

						if ((LA92_0==102))
						{
							alt92=1;
						}


						} finally { DebugExitDecision(92); }
						switch ( alt92 )
						{
						case 1:
							DebugEnterAlt(1);
							// cs.g:341:25: '*'
							{
							DebugLocation(341, 25);
							char_literal312=(IToken)Match(input,102,Follow._102_in_non_nullable_type2658); if (state.failed) return retval;
							if ( state.backtracking==0 ) {
							char_literal312_tree = (object)adaptor.Create(char_literal312);
							adaptor.AddChild(root_0, char_literal312_tree);
							}

							}
							break;

						default:
							goto loop92;
						}
					}

					loop92:
						;

					} finally { DebugExitSubRule(92); }


					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:342:6: ( ( '*' )+ )?
					{
					DebugLocation(342, 6);
					// cs.g:342:6: ( ( '*' )+ )?
					int alt94=2;
					try { DebugEnterSubRule(94);
					try { DebugEnterDecision(94, decisionCanBacktrack[94]);
					int LA94_0 = input.LA(1);

					if ((LA94_0==102))
					{
						alt94=1;
					}
					} finally { DebugExitDecision(94); }
					switch (alt94)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:342:7: ( '*' )+
						{
						DebugLocation(342, 7);
						// cs.g:342:7: ( '*' )+
						int cnt93=0;
						try { DebugEnterSubRule(93);
						while (true)
						{
							int alt93=2;
							try { DebugEnterDecision(93, decisionCanBacktrack[93]);
							int LA93_0 = input.LA(1);

							if ((LA93_0==102))
							{
								alt93=1;
							}


							} finally { DebugExitDecision(93); }
							switch (alt93)
							{
							case 1:
								DebugEnterAlt(1);
								// cs.g:342:7: '*'
								{
								DebugLocation(342, 7);
								char_literal313=(IToken)Match(input,102,Follow._102_in_non_nullable_type2667); if (state.failed) return retval;
								if ( state.backtracking==0 ) {
								char_literal313_tree = (object)adaptor.Create(char_literal313);
								adaptor.AddChild(root_0, char_literal313_tree);
								}

								}
								break;

							default:
								if (cnt93 >= 1)
									goto loop93;

								if (state.backtracking>0) {state.failed=true; return retval;}
								EarlyExitException eee93 = new EarlyExitException( 93, input );
								DebugRecognitionException(eee93);
								throw eee93;
							}
							cnt93++;
						}
						loop93:
							;

						} finally { DebugExitSubRule(93); }


						}
						break;

					}
					} finally { DebugExitSubRule(94); }


					}
					break;

				}
				} finally { DebugExitSubRule(95); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:344:4: 'void' ( '*' )+
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(344, 4);
				string_literal314=(IToken)Match(input,82,Follow._82_in_non_nullable_type2679); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal314_tree = (object)adaptor.Create(string_literal314);
				adaptor.AddChild(root_0, string_literal314_tree);
				}
				DebugLocation(344, 13);
				// cs.g:344:13: ( '*' )+
				int cnt96=0;
				try { DebugEnterSubRule(96);
				while (true)
				{
					int alt96=2;
					try { DebugEnterDecision(96, decisionCanBacktrack[96]);
					int LA96_0 = input.LA(1);

					if ((LA96_0==102))
					{
						alt96=1;
					}


					} finally { DebugExitDecision(96); }
					switch (alt96)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:344:13: '*'
						{
						DebugLocation(344, 13);
						char_literal315=(IToken)Match(input,102,Follow._102_in_non_nullable_type2683); if (state.failed) return retval;
						if ( state.backtracking==0 ) {
						char_literal315_tree = (object)adaptor.Create(char_literal315);
						adaptor.AddChild(root_0, char_literal315_tree);
						}

						}
						break;

					default:
						if (cnt96 >= 1)
							goto loop96;

						if (state.backtracking>0) {state.failed=true; return retval;}
						EarlyExitException eee96 = new EarlyExitException( 96, input );
						DebugRecognitionException(eee96);
						throw eee96;
					}
					cnt96++;
				}
				loop96:
					;

				} finally { DebugExitSubRule(96); }


				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("non_nullable_type", 80);
			LeaveRule("non_nullable_type", 80);
			Leave_non_nullable_type();
			if (state.backtracking > 0) { Memoize(input, 80, non_nullable_type_StartIndex); }
		}
		DebugLocation(344, 17);
		} finally { DebugExitRule(GrammarFileName, "non_nullable_type"); }
		return retval;

	}
	// $ANTLR end "non_nullable_type"

	public class non_array_type_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_non_array_type();
	partial void Leave_non_array_type();

	// $ANTLR start "non_array_type"
	// cs.g:346:8: public non_array_type : type ;
	[GrammarRule("non_array_type")]
	public csParser.non_array_type_return non_array_type()
	{
		Enter_non_array_type();
		EnterRule("non_array_type", 81);
		TraceIn("non_array_type", 81);
		csParser.non_array_type_return retval = new csParser.non_array_type_return();
		retval.Start = (IToken)input.LT(1);
		int non_array_type_StartIndex = input.Index;
		object root_0 = null;

		csParser.type_return type316 = default(csParser.type_return);


		try { DebugEnterRule(GrammarFileName, "non_array_type");
		DebugLocation(346, 5);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 81)) { return retval; }
			// cs.g:346:22: ( type )
			DebugEnterAlt(1);
			// cs.g:347:2: type
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(347, 2);
			PushFollow(Follow._type_in_non_array_type2696);
			type316=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type316.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("non_array_type", 81);
			LeaveRule("non_array_type", 81);
			Leave_non_array_type();
			if (state.backtracking > 0) { Memoize(input, 81, non_array_type_StartIndex); }
		}
		DebugLocation(347, 5);
		} finally { DebugExitRule(GrammarFileName, "non_array_type"); }
		return retval;

	}
	// $ANTLR end "non_array_type"

	public class array_type_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_array_type();
	partial void Leave_array_type();

	// $ANTLR start "array_type"
	// cs.g:348:8: public array_type : type ;
	[GrammarRule("array_type")]
	public csParser.array_type_return array_type()
	{
		Enter_array_type();
		EnterRule("array_type", 82);
		TraceIn("array_type", 82);
		csParser.array_type_return retval = new csParser.array_type_return();
		retval.Start = (IToken)input.LT(1);
		int array_type_StartIndex = input.Index;
		object root_0 = null;

		csParser.type_return type317 = default(csParser.type_return);


		try { DebugEnterRule(GrammarFileName, "array_type");
		DebugLocation(348, 5);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 82)) { return retval; }
			// cs.g:348:18: ( type )
			DebugEnterAlt(1);
			// cs.g:349:2: type
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(349, 2);
			PushFollow(Follow._type_in_array_type2705);
			type317=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type317.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("array_type", 82);
			LeaveRule("array_type", 82);
			Leave_array_type();
			if (state.backtracking > 0) { Memoize(input, 82, array_type_StartIndex); }
		}
		DebugLocation(349, 5);
		} finally { DebugExitRule(GrammarFileName, "array_type"); }
		return retval;

	}
	// $ANTLR end "array_type"

	public class unmanaged_type_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_unmanaged_type();
	partial void Leave_unmanaged_type();

	// $ANTLR start "unmanaged_type"
	// cs.g:350:8: public unmanaged_type : type ;
	[GrammarRule("unmanaged_type")]
	public csParser.unmanaged_type_return unmanaged_type()
	{
		Enter_unmanaged_type();
		EnterRule("unmanaged_type", 83);
		TraceIn("unmanaged_type", 83);
		csParser.unmanaged_type_return retval = new csParser.unmanaged_type_return();
		retval.Start = (IToken)input.LT(1);
		int unmanaged_type_StartIndex = input.Index;
		object root_0 = null;

		csParser.type_return type318 = default(csParser.type_return);


		try { DebugEnterRule(GrammarFileName, "unmanaged_type");
		DebugLocation(350, 5);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 83)) { return retval; }
			// cs.g:350:22: ( type )
			DebugEnterAlt(1);
			// cs.g:351:2: type
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(351, 2);
			PushFollow(Follow._type_in_unmanaged_type2714);
			type318=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type318.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("unmanaged_type", 83);
			LeaveRule("unmanaged_type", 83);
			Leave_unmanaged_type();
			if (state.backtracking > 0) { Memoize(input, 83, unmanaged_type_StartIndex); }
		}
		DebugLocation(351, 5);
		} finally { DebugExitRule(GrammarFileName, "unmanaged_type"); }
		return retval;

	}
	// $ANTLR end "unmanaged_type"

	public class class_type_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_class_type();
	partial void Leave_class_type();

	// $ANTLR start "class_type"
	// cs.g:352:8: public class_type : type ;
	[GrammarRule("class_type")]
	public csParser.class_type_return class_type()
	{
		Enter_class_type();
		EnterRule("class_type", 84);
		TraceIn("class_type", 84);
		csParser.class_type_return retval = new csParser.class_type_return();
		retval.Start = (IToken)input.LT(1);
		int class_type_StartIndex = input.Index;
		object root_0 = null;

		csParser.type_return type319 = default(csParser.type_return);


		try { DebugEnterRule(GrammarFileName, "class_type");
		DebugLocation(352, 5);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 84)) { return retval; }
			// cs.g:352:18: ( type )
			DebugEnterAlt(1);
			// cs.g:353:2: type
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(353, 2);
			PushFollow(Follow._type_in_class_type2723);
			type319=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type319.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("class_type", 84);
			LeaveRule("class_type", 84);
			Leave_class_type();
			if (state.backtracking > 0) { Memoize(input, 84, class_type_StartIndex); }
		}
		DebugLocation(353, 5);
		} finally { DebugExitRule(GrammarFileName, "class_type"); }
		return retval;

	}
	// $ANTLR end "class_type"

	public class pointer_type_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_pointer_type();
	partial void Leave_pointer_type();

	// $ANTLR start "pointer_type"
	// cs.g:354:8: public pointer_type : type ;
	[GrammarRule("pointer_type")]
	public csParser.pointer_type_return pointer_type()
	{
		Enter_pointer_type();
		EnterRule("pointer_type", 85);
		TraceIn("pointer_type", 85);
		csParser.pointer_type_return retval = new csParser.pointer_type_return();
		retval.Start = (IToken)input.LT(1);
		int pointer_type_StartIndex = input.Index;
		object root_0 = null;

		csParser.type_return type320 = default(csParser.type_return);


		try { DebugEnterRule(GrammarFileName, "pointer_type");
		DebugLocation(354, 5);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 85)) { return retval; }
			// cs.g:354:20: ( type )
			DebugEnterAlt(1);
			// cs.g:355:2: type
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(355, 2);
			PushFollow(Follow._type_in_pointer_type2732);
			type320=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type320.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("pointer_type", 85);
			LeaveRule("pointer_type", 85);
			Leave_pointer_type();
			if (state.backtracking > 0) { Memoize(input, 85, pointer_type_StartIndex); }
		}
		DebugLocation(355, 5);
		} finally { DebugExitRule(GrammarFileName, "pointer_type"); }
		return retval;

	}
	// $ANTLR end "pointer_type"

	public class block_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_block();
	partial void Leave_block();

	// $ANTLR start "block"
	// cs.g:361:8: public block : ( ';' | '{' ( statement_list )? '}' );
	[GrammarRule("block")]
	public csParser.block_return block()
	{
		Enter_block();
		EnterRule("block", 86);
		TraceIn("block", 86);
		csParser.block_return retval = new csParser.block_return();
		retval.Start = (IToken)input.LT(1);
		int block_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal321=null;
		IToken char_literal322=null;
		IToken char_literal324=null;
		csParser.statement_list_return statement_list323 = default(csParser.statement_list_return);

		object char_literal321_tree=null;
		object char_literal322_tree=null;
		object char_literal324_tree=null;

		try { DebugEnterRule(GrammarFileName, "block");
		DebugLocation(361, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 86)) { return retval; }
			// cs.g:361:13: ( ';' | '{' ( statement_list )? '}' )
			int alt99=2;
			try { DebugEnterDecision(99, decisionCanBacktrack[99]);
			int LA99_0 = input.LA(1);

			if ((LA99_0==SEMI))
			{
				alt99=1;
			}
			else if ((LA99_0==62))
			{
				alt99=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 99, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(99); }
			switch (alt99)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:362:2: ';'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(362, 2);
				char_literal321=(IToken)Match(input,SEMI,Follow._SEMI_in_block2746); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal321_tree = (object)adaptor.Create(char_literal321);
				adaptor.AddChild(root_0, char_literal321_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:363:4: '{' ( statement_list )? '}'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(363, 4);
				char_literal322=(IToken)Match(input,62,Follow._62_in_block2751); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal322_tree = (object)adaptor.Create(char_literal322);
				adaptor.AddChild(root_0, char_literal322_tree);
				}
				DebugLocation(363, 10);
				// cs.g:363:10: ( statement_list )?
				int alt98=2;
				try { DebugEnterSubRule(98);
				try { DebugEnterDecision(98, decisionCanBacktrack[98]);
				int LA98_0 = input.LA(1);

				if (((LA98_0>=IDENTIFIER && LA98_0<=NULL)||LA98_0==MINUS||LA98_0==USING||(LA98_0>=IF && LA98_0<=SEMI)||LA98_0==62||LA98_0==65||LA98_0==68||LA98_0==73||(LA98_0>=81 && LA98_0<=84)||(LA98_0>=86 && LA98_0<=87)||LA98_0==90||(LA98_0>=95 && LA98_0<=100)||LA98_0==102||(LA98_0>=104 && LA98_0<=106)||LA98_0==117||(LA98_0>=132 && LA98_0<=133)||(LA98_0>=135 && LA98_0<=148)||(LA98_0>=150 && LA98_0<=154)||(LA98_0>=156 && LA98_0<=168)||LA98_0==170||(LA98_0>=176 && LA98_0<=178)||LA98_0==181||(LA98_0>=183 && LA98_0<=191)||(LA98_0>=194 && LA98_0<=202)))
				{
					alt98=1;
				}
				} finally { DebugExitDecision(98); }
				switch (alt98)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:363:10: statement_list
					{
					DebugLocation(363, 10);
					PushFollow(Follow._statement_list_in_block2755);
					statement_list323=statement_list();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_list323.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(98); }

				DebugLocation(363, 28);
				char_literal324=(IToken)Match(input,63,Follow._63_in_block2760); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal324_tree = (object)adaptor.Create(char_literal324);
				adaptor.AddChild(root_0, char_literal324_tree);
				}

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("block", 86);
			LeaveRule("block", 86);
			Leave_block();
			if (state.backtracking > 0) { Memoize(input, 86, block_StartIndex); }
		}
		DebugLocation(363, 30);
		} finally { DebugExitRule(GrammarFileName, "block"); }
		return retval;

	}
	// $ANTLR end "block"

	public class statement_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_statement_list();
	partial void Leave_statement_list();

	// $ANTLR start "statement_list"
	// cs.g:364:8: public statement_list : ( statement )+ ;
	[GrammarRule("statement_list")]
	public csParser.statement_list_return statement_list()
	{
		Enter_statement_list();
		EnterRule("statement_list", 87);
		TraceIn("statement_list", 87);
		csParser.statement_list_return retval = new csParser.statement_list_return();
		retval.Start = (IToken)input.LT(1);
		int statement_list_StartIndex = input.Index;
		object root_0 = null;

		csParser.statement_return statement325 = default(csParser.statement_return);


		try { DebugEnterRule(GrammarFileName, "statement_list");
		DebugLocation(364, 12);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 87)) { return retval; }
			// cs.g:364:22: ( ( statement )+ )
			DebugEnterAlt(1);
			// cs.g:365:2: ( statement )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(365, 2);
			// cs.g:365:2: ( statement )+
			int cnt100=0;
			try { DebugEnterSubRule(100);
			while (true)
			{
				int alt100=2;
				try { DebugEnterDecision(100, decisionCanBacktrack[100]);
				int LA100_0 = input.LA(1);

				if ((LA100_0==98))
				{
					int LA100_2 = input.LA(2);

					if ((LA100_2==90))
					{
						alt100=1;
					}


				}
				else if (((LA100_0>=IDENTIFIER && LA100_0<=NULL)||LA100_0==MINUS||LA100_0==USING||(LA100_0>=IF && LA100_0<=SEMI)||LA100_0==62||LA100_0==65||LA100_0==68||LA100_0==73||(LA100_0>=81 && LA100_0<=84)||(LA100_0>=86 && LA100_0<=87)||LA100_0==90||(LA100_0>=95 && LA100_0<=97)||(LA100_0>=99 && LA100_0<=100)||LA100_0==102||(LA100_0>=104 && LA100_0<=106)||LA100_0==117||(LA100_0>=132 && LA100_0<=133)||(LA100_0>=135 && LA100_0<=148)||(LA100_0>=150 && LA100_0<=154)||(LA100_0>=156 && LA100_0<=168)||LA100_0==170||(LA100_0>=176 && LA100_0<=178)||LA100_0==181||(LA100_0>=183 && LA100_0<=191)||(LA100_0>=194 && LA100_0<=202)))
				{
					alt100=1;
				}


				} finally { DebugExitDecision(100); }
				switch (alt100)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:365:2: statement
					{
					DebugLocation(365, 2);
					PushFollow(Follow._statement_in_statement_list2769);
					statement325=statement();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement325.Tree);

					}
					break;

				default:
					if (cnt100 >= 1)
						goto loop100;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee100 = new EarlyExitException( 100, input );
					DebugRecognitionException(eee100);
					throw eee100;
				}
				cnt100++;
			}
			loop100:
				;

			} finally { DebugExitSubRule(100); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("statement_list", 87);
			LeaveRule("statement_list", 87);
			Leave_statement_list();
			if (state.backtracking > 0) { Memoize(input, 87, statement_list_StartIndex); }
		}
		DebugLocation(365, 12);
		} finally { DebugExitRule(GrammarFileName, "statement_list"); }
		return retval;

	}
	// $ANTLR end "statement_list"

	public class expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_expression();
	partial void Leave_expression();

	// $ANTLR start "expression"
	// cs.g:370:8: public expression : ( ( unary_expression assignment_operator )=> assignment | non_assignment_expression );
	[GrammarRule("expression")]
	public csParser.expression_return expression()
	{
		Enter_expression();
		EnterRule("expression", 88);
		TraceIn("expression", 88);
		csParser.expression_return retval = new csParser.expression_return();
		retval.Start = (IToken)input.LT(1);
		int expression_StartIndex = input.Index;
		object root_0 = null;

		csParser.assignment_return assignment326 = default(csParser.assignment_return);
		csParser.non_assignment_expression_return non_assignment_expression327 = default(csParser.non_assignment_expression_return);


		try { DebugEnterRule(GrammarFileName, "expression");
		DebugLocation(370, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 88)) { return retval; }
			// cs.g:370:18: ( ( unary_expression assignment_operator )=> assignment | non_assignment_expression )
			int alt101=2;
			try { DebugEnterDecision(101, decisionCanBacktrack[101]);
			try
			{
				alt101 = dfa101.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(101); }
			switch (alt101)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:371:2: ( unary_expression assignment_operator )=> assignment
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(371, 46);
				PushFollow(Follow._assignment_in_expression2796);
				assignment326=assignment();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignment326.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:372:4: non_assignment_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(372, 4);
				PushFollow(Follow._non_assignment_expression_in_expression2802);
				non_assignment_expression327=non_assignment_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, non_assignment_expression327.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("expression", 88);
			LeaveRule("expression", 88);
			Leave_expression();
			if (state.backtracking > 0) { Memoize(input, 88, expression_StartIndex); }
		}
		DebugLocation(373, 1);
		} finally { DebugExitRule(GrammarFileName, "expression"); }
		return retval;

	}
	// $ANTLR end "expression"

	public class expression_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_expression_list();
	partial void Leave_expression_list();

	// $ANTLR start "expression_list"
	// cs.g:374:8: public expression_list : expression ( ',' expression )* ;
	[GrammarRule("expression_list")]
	public csParser.expression_list_return expression_list()
	{
		Enter_expression_list();
		EnterRule("expression_list", 89);
		TraceIn("expression_list", 89);
		csParser.expression_list_return retval = new csParser.expression_list_return();
		retval.Start = (IToken)input.LT(1);
		int expression_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal329=null;
		csParser.expression_return expression328 = default(csParser.expression_return);
		csParser.expression_return expression330 = default(csParser.expression_return);

		object char_literal329_tree=null;

		try { DebugEnterRule(GrammarFileName, "expression_list");
		DebugLocation(374, 33);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 89)) { return retval; }
			// cs.g:374:23: ( expression ( ',' expression )* )
			DebugEnterAlt(1);
			// cs.g:375:2: expression ( ',' expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(375, 2);
			PushFollow(Follow._expression_in_expression_list2813);
			expression328=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression328.Tree);
			DebugLocation(375, 14);
			// cs.g:375:14: ( ',' expression )*
			try { DebugEnterSubRule(102);
			while (true)
			{
				int alt102=2;
				try { DebugEnterDecision(102, decisionCanBacktrack[102]);
				int LA102_0 = input.LA(1);

				if ((LA102_0==91))
				{
					alt102=1;
				}


				} finally { DebugExitDecision(102); }
				switch ( alt102 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:375:15: ',' expression
					{
					DebugLocation(375, 15);
					char_literal329=(IToken)Match(input,91,Follow._91_in_expression_list2817); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal329_tree = (object)adaptor.Create(char_literal329);
					adaptor.AddChild(root_0, char_literal329_tree);
					}
					DebugLocation(375, 21);
					PushFollow(Follow._expression_in_expression_list2821);
					expression330=expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression330.Tree);

					}
					break;

				default:
					goto loop102;
				}
			}

			loop102:
				;

			} finally { DebugExitSubRule(102); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("expression_list", 89);
			LeaveRule("expression_list", 89);
			Leave_expression_list();
			if (state.backtracking > 0) { Memoize(input, 89, expression_list_StartIndex); }
		}
		DebugLocation(375, 33);
		} finally { DebugExitRule(GrammarFileName, "expression_list"); }
		return retval;

	}
	// $ANTLR end "expression_list"

	public class assignment_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_assignment();
	partial void Leave_assignment();

	// $ANTLR start "assignment"
	// cs.g:376:8: public assignment : unary_expression assignment_operator expression ;
	[GrammarRule("assignment")]
	public csParser.assignment_return assignment()
	{
		Enter_assignment();
		EnterRule("assignment", 90);
		TraceIn("assignment", 90);
		csParser.assignment_return retval = new csParser.assignment_return();
		retval.Start = (IToken)input.LT(1);
		int assignment_StartIndex = input.Index;
		object root_0 = null;

		csParser.unary_expression_return unary_expression331 = default(csParser.unary_expression_return);
		csParser.assignment_operator_return assignment_operator332 = default(csParser.assignment_operator_return);
		csParser.expression_return expression333 = default(csParser.expression_return);


		try { DebugEnterRule(GrammarFileName, "assignment");
		DebugLocation(376, 53);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 90)) { return retval; }
			// cs.g:376:18: ( unary_expression assignment_operator expression )
			DebugEnterAlt(1);
			// cs.g:377:2: unary_expression assignment_operator expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(377, 2);
			PushFollow(Follow._unary_expression_in_assignment2833);
			unary_expression331=unary_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression331.Tree);
			DebugLocation(377, 21);
			PushFollow(Follow._assignment_operator_in_assignment2837);
			assignment_operator332=assignment_operator();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignment_operator332.Tree);
			DebugLocation(377, 43);
			PushFollow(Follow._expression_in_assignment2841);
			expression333=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression333.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("assignment", 90);
			LeaveRule("assignment", 90);
			Leave_assignment();
			if (state.backtracking > 0) { Memoize(input, 90, assignment_StartIndex); }
		}
		DebugLocation(377, 53);
		} finally { DebugExitRule(GrammarFileName, "assignment"); }
		return retval;

	}
	// $ANTLR end "assignment"

	public class unary_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_unary_expression();
	partial void Leave_unary_expression();

	// $ANTLR start "unary_expression"
	// cs.g:378:8: public unary_expression : ( ( cast_expression )=> cast_expression | primary_or_array_creation_expression | '+' unary_expression | '-' unary_expression | '!' unary_expression | '~' unary_expression | pre_increment_expression | pre_decrement_expression | pointer_indirection_expression | addressof_expression );
	[GrammarRule("unary_expression")]
	public csParser.unary_expression_return unary_expression()
	{
		Enter_unary_expression();
		EnterRule("unary_expression", 91);
		TraceIn("unary_expression", 91);
		csParser.unary_expression_return retval = new csParser.unary_expression_return();
		retval.Start = (IToken)input.LT(1);
		int unary_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal336=null;
		IToken char_literal338=null;
		IToken char_literal340=null;
		IToken char_literal342=null;
		csParser.cast_expression_return cast_expression334 = default(csParser.cast_expression_return);
		csParser.primary_or_array_creation_expression_return primary_or_array_creation_expression335 = default(csParser.primary_or_array_creation_expression_return);
		csParser.unary_expression_return unary_expression337 = default(csParser.unary_expression_return);
		csParser.unary_expression_return unary_expression339 = default(csParser.unary_expression_return);
		csParser.unary_expression_return unary_expression341 = default(csParser.unary_expression_return);
		csParser.unary_expression_return unary_expression343 = default(csParser.unary_expression_return);
		csParser.pre_increment_expression_return pre_increment_expression344 = default(csParser.pre_increment_expression_return);
		csParser.pre_decrement_expression_return pre_decrement_expression345 = default(csParser.pre_decrement_expression_return);
		csParser.pointer_indirection_expression_return pointer_indirection_expression346 = default(csParser.pointer_indirection_expression_return);
		csParser.addressof_expression_return addressof_expression347 = default(csParser.addressof_expression_return);

		object char_literal336_tree=null;
		object char_literal338_tree=null;
		object char_literal340_tree=null;
		object char_literal342_tree=null;

		try { DebugEnterRule(GrammarFileName, "unary_expression");
		DebugLocation(378, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 91)) { return retval; }
			// cs.g:378:24: ( ( cast_expression )=> cast_expression | primary_or_array_creation_expression | '+' unary_expression | '-' unary_expression | '!' unary_expression | '~' unary_expression | pre_increment_expression | pre_decrement_expression | pointer_indirection_expression | addressof_expression )
			int alt103=10;
			try { DebugEnterDecision(103, decisionCanBacktrack[103]);
			try
			{
				alt103 = dfa103.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(103); }
			switch (alt103)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:380:2: ( cast_expression )=> cast_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(380, 23);
				PushFollow(Follow._cast_expression_in_unary_expression2860);
				cast_expression334=cast_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, cast_expression334.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:381:4: primary_or_array_creation_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(381, 4);
				PushFollow(Follow._primary_or_array_creation_expression_in_unary_expression2865);
				primary_or_array_creation_expression335=primary_or_array_creation_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_or_array_creation_expression335.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:382:4: '+' unary_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(382, 4);
				char_literal336=(IToken)Match(input,104,Follow._104_in_unary_expression2870); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal336_tree = (object)adaptor.Create(char_literal336);
				adaptor.AddChild(root_0, char_literal336_tree);
				}
				DebugLocation(382, 10);
				PushFollow(Follow._unary_expression_in_unary_expression2874);
				unary_expression337=unary_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression337.Tree);

				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:383:4: '-' unary_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(383, 4);
				char_literal338=(IToken)Match(input,MINUS,Follow._MINUS_in_unary_expression2880); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal338_tree = (object)adaptor.Create(char_literal338);
				adaptor.AddChild(root_0, char_literal338_tree);
				}
				DebugLocation(383, 10);
				PushFollow(Follow._unary_expression_in_unary_expression2884);
				unary_expression339=unary_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression339.Tree);

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:384:4: '!' unary_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(384, 4);
				char_literal340=(IToken)Match(input,105,Follow._105_in_unary_expression2890); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal340_tree = (object)adaptor.Create(char_literal340);
				adaptor.AddChild(root_0, char_literal340_tree);
				}
				DebugLocation(384, 10);
				PushFollow(Follow._unary_expression_in_unary_expression2894);
				unary_expression341=unary_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression341.Tree);

				}
				break;
			case 6:
				DebugEnterAlt(6);
				// cs.g:385:4: '~' unary_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(385, 4);
				char_literal342=(IToken)Match(input,106,Follow._106_in_unary_expression2900); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal342_tree = (object)adaptor.Create(char_literal342);
				adaptor.AddChild(root_0, char_literal342_tree);
				}
				DebugLocation(385, 10);
				PushFollow(Follow._unary_expression_in_unary_expression2904);
				unary_expression343=unary_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression343.Tree);

				}
				break;
			case 7:
				DebugEnterAlt(7);
				// cs.g:386:4: pre_increment_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(386, 4);
				PushFollow(Follow._pre_increment_expression_in_unary_expression2910);
				pre_increment_expression344=pre_increment_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, pre_increment_expression344.Tree);

				}
				break;
			case 8:
				DebugEnterAlt(8);
				// cs.g:387:4: pre_decrement_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(387, 4);
				PushFollow(Follow._pre_decrement_expression_in_unary_expression2916);
				pre_decrement_expression345=pre_decrement_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, pre_decrement_expression345.Tree);

				}
				break;
			case 9:
				DebugEnterAlt(9);
				// cs.g:388:4: pointer_indirection_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(388, 4);
				PushFollow(Follow._pointer_indirection_expression_in_unary_expression2922);
				pointer_indirection_expression346=pointer_indirection_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, pointer_indirection_expression346.Tree);

				}
				break;
			case 10:
				DebugEnterAlt(10);
				// cs.g:389:4: addressof_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(389, 4);
				PushFollow(Follow._addressof_expression_in_unary_expression2927);
				addressof_expression347=addressof_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, addressof_expression347.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("unary_expression", 91);
			LeaveRule("unary_expression", 91);
			Leave_unary_expression();
			if (state.backtracking > 0) { Memoize(input, 91, unary_expression_StartIndex); }
		}
		DebugLocation(390, 1);
		} finally { DebugExitRule(GrammarFileName, "unary_expression"); }
		return retval;

	}
	// $ANTLR end "unary_expression"

	public class cast_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_cast_expression();
	partial void Leave_cast_expression();

	// $ANTLR start "cast_expression"
	// cs.g:391:8: public cast_expression : '(' type ')' unary_expression ;
	[GrammarRule("cast_expression")]
	public csParser.cast_expression_return cast_expression()
	{
		Enter_cast_expression();
		EnterRule("cast_expression", 92);
		TraceIn("cast_expression", 92);
		csParser.cast_expression_return retval = new csParser.cast_expression_return();
		retval.Start = (IToken)input.LT(1);
		int cast_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal348=null;
		IToken char_literal350=null;
		csParser.type_return type349 = default(csParser.type_return);
		csParser.unary_expression_return unary_expression351 = default(csParser.unary_expression_return);

		object char_literal348_tree=null;
		object char_literal350_tree=null;

		try { DebugEnterRule(GrammarFileName, "cast_expression");
		DebugLocation(391, 37);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 92)) { return retval; }
			// cs.g:391:23: ( '(' type ')' unary_expression )
			DebugEnterAlt(1);
			// cs.g:392:2: '(' type ')' unary_expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(392, 2);
			char_literal348=(IToken)Match(input,90,Follow._90_in_cast_expression2939); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal348_tree = (object)adaptor.Create(char_literal348);
			adaptor.AddChild(root_0, char_literal348_tree);
			}
			DebugLocation(392, 8);
			PushFollow(Follow._type_in_cast_expression2943);
			type349=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type349.Tree);
			DebugLocation(392, 15);
			char_literal350=(IToken)Match(input,RPAREN,Follow._RPAREN_in_cast_expression2947); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal350_tree = (object)adaptor.Create(char_literal350);
			adaptor.AddChild(root_0, char_literal350_tree);
			}
			DebugLocation(392, 21);
			PushFollow(Follow._unary_expression_in_cast_expression2951);
			unary_expression351=unary_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression351.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("cast_expression", 92);
			LeaveRule("cast_expression", 92);
			Leave_cast_expression();
			if (state.backtracking > 0) { Memoize(input, 92, cast_expression_StartIndex); }
		}
		DebugLocation(392, 37);
		} finally { DebugExitRule(GrammarFileName, "cast_expression"); }
		return retval;

	}
	// $ANTLR end "cast_expression"

	public class assignment_operator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_assignment_operator();
	partial void Leave_assignment_operator();

	// $ANTLR start "assignment_operator"
	// cs.g:393:8: public assignment_operator : ( '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>' '>=' );
	[GrammarRule("assignment_operator")]
	public csParser.assignment_operator_return assignment_operator()
	{
		Enter_assignment_operator();
		EnterRule("assignment_operator", 93);
		TraceIn("assignment_operator", 93);
		csParser.assignment_operator_return retval = new csParser.assignment_operator_return();
		retval.Start = (IToken)input.LT(1);
		int assignment_operator_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal352=null;
		IToken string_literal353=null;
		IToken string_literal354=null;
		IToken string_literal355=null;
		IToken string_literal356=null;
		IToken string_literal357=null;
		IToken string_literal358=null;
		IToken string_literal359=null;
		IToken string_literal360=null;
		IToken string_literal361=null;
		IToken char_literal362=null;
		IToken string_literal363=null;

		object char_literal352_tree=null;
		object string_literal353_tree=null;
		object string_literal354_tree=null;
		object string_literal355_tree=null;
		object string_literal356_tree=null;
		object string_literal357_tree=null;
		object string_literal358_tree=null;
		object string_literal359_tree=null;
		object string_literal360_tree=null;
		object string_literal361_tree=null;
		object char_literal362_tree=null;
		object string_literal363_tree=null;

		try { DebugEnterRule(GrammarFileName, "assignment_operator");
		DebugLocation(393, 80);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 93)) { return retval; }
			// cs.g:393:27: ( '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>' '>=' )
			int alt104=11;
			try { DebugEnterDecision(104, decisionCanBacktrack[104]);
			try
			{
				alt104 = dfa104.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(104); }
			switch (alt104)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:394:2: '='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(394, 2);
				char_literal352=(IToken)Match(input,66,Follow._66_in_assignment_operator2961); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal352_tree = (object)adaptor.Create(char_literal352);
				adaptor.AddChild(root_0, char_literal352_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:394:8: '+='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(394, 8);
				string_literal353=(IToken)Match(input,107,Follow._107_in_assignment_operator2965); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal353_tree = (object)adaptor.Create(string_literal353);
				adaptor.AddChild(root_0, string_literal353_tree);
				}

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:394:15: '-='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(394, 15);
				string_literal354=(IToken)Match(input,108,Follow._108_in_assignment_operator2969); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal354_tree = (object)adaptor.Create(string_literal354);
				adaptor.AddChild(root_0, string_literal354_tree);
				}

				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:394:22: '*='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(394, 22);
				string_literal355=(IToken)Match(input,109,Follow._109_in_assignment_operator2973); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal355_tree = (object)adaptor.Create(string_literal355);
				adaptor.AddChild(root_0, string_literal355_tree);
				}

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:394:29: '/='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(394, 29);
				string_literal356=(IToken)Match(input,110,Follow._110_in_assignment_operator2977); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal356_tree = (object)adaptor.Create(string_literal356);
				adaptor.AddChild(root_0, string_literal356_tree);
				}

				}
				break;
			case 6:
				DebugEnterAlt(6);
				// cs.g:394:36: '%='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(394, 36);
				string_literal357=(IToken)Match(input,111,Follow._111_in_assignment_operator2981); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal357_tree = (object)adaptor.Create(string_literal357);
				adaptor.AddChild(root_0, string_literal357_tree);
				}

				}
				break;
			case 7:
				DebugEnterAlt(7);
				// cs.g:394:43: '&='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(394, 43);
				string_literal358=(IToken)Match(input,112,Follow._112_in_assignment_operator2985); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal358_tree = (object)adaptor.Create(string_literal358);
				adaptor.AddChild(root_0, string_literal358_tree);
				}

				}
				break;
			case 8:
				DebugEnterAlt(8);
				// cs.g:394:50: '|='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(394, 50);
				string_literal359=(IToken)Match(input,113,Follow._113_in_assignment_operator2989); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal359_tree = (object)adaptor.Create(string_literal359);
				adaptor.AddChild(root_0, string_literal359_tree);
				}

				}
				break;
			case 9:
				DebugEnterAlt(9);
				// cs.g:394:57: '^='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(394, 57);
				string_literal360=(IToken)Match(input,114,Follow._114_in_assignment_operator2993); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal360_tree = (object)adaptor.Create(string_literal360);
				adaptor.AddChild(root_0, string_literal360_tree);
				}

				}
				break;
			case 10:
				DebugEnterAlt(10);
				// cs.g:394:64: '<<='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(394, 64);
				string_literal361=(IToken)Match(input,115,Follow._115_in_assignment_operator2997); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal361_tree = (object)adaptor.Create(string_literal361);
				adaptor.AddChild(root_0, string_literal361_tree);
				}

				}
				break;
			case 11:
				DebugEnterAlt(11);
				// cs.g:394:72: '>' '>='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(394, 72);
				char_literal362=(IToken)Match(input,GT,Follow._GT_in_assignment_operator3001); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal362_tree = (object)adaptor.Create(char_literal362);
				adaptor.AddChild(root_0, char_literal362_tree);
				}
				DebugLocation(394, 76);
				string_literal363=(IToken)Match(input,116,Follow._116_in_assignment_operator3003); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal363_tree = (object)adaptor.Create(string_literal363);
				adaptor.AddChild(root_0, string_literal363_tree);
				}

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("assignment_operator", 93);
			LeaveRule("assignment_operator", 93);
			Leave_assignment_operator();
			if (state.backtracking > 0) { Memoize(input, 93, assignment_operator_StartIndex); }
		}
		DebugLocation(394, 80);
		} finally { DebugExitRule(GrammarFileName, "assignment_operator"); }
		return retval;

	}
	// $ANTLR end "assignment_operator"

	public class pre_increment_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_pre_increment_expression();
	partial void Leave_pre_increment_expression();

	// $ANTLR start "pre_increment_expression"
	// cs.g:395:8: public pre_increment_expression : '++' unary_expression ;
	[GrammarRule("pre_increment_expression")]
	public csParser.pre_increment_expression_return pre_increment_expression()
	{
		Enter_pre_increment_expression();
		EnterRule("pre_increment_expression", 94);
		TraceIn("pre_increment_expression", 94);
		csParser.pre_increment_expression_return retval = new csParser.pre_increment_expression_return();
		retval.Start = (IToken)input.LT(1);
		int pre_increment_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal364=null;
		csParser.unary_expression_return unary_expression365 = default(csParser.unary_expression_return);

		object string_literal364_tree=null;

		try { DebugEnterRule(GrammarFileName, "pre_increment_expression");
		DebugLocation(395, 25);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 94)) { return retval; }
			// cs.g:395:32: ( '++' unary_expression )
			DebugEnterAlt(1);
			// cs.g:396:2: '++' unary_expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(396, 2);
			string_literal364=(IToken)Match(input,86,Follow._86_in_pre_increment_expression3014); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal364_tree = (object)adaptor.Create(string_literal364);
			adaptor.AddChild(root_0, string_literal364_tree);
			}
			DebugLocation(396, 9);
			PushFollow(Follow._unary_expression_in_pre_increment_expression3018);
			unary_expression365=unary_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression365.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("pre_increment_expression", 94);
			LeaveRule("pre_increment_expression", 94);
			Leave_pre_increment_expression();
			if (state.backtracking > 0) { Memoize(input, 94, pre_increment_expression_StartIndex); }
		}
		DebugLocation(396, 25);
		} finally { DebugExitRule(GrammarFileName, "pre_increment_expression"); }
		return retval;

	}
	// $ANTLR end "pre_increment_expression"

	public class pre_decrement_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_pre_decrement_expression();
	partial void Leave_pre_decrement_expression();

	// $ANTLR start "pre_decrement_expression"
	// cs.g:397:8: public pre_decrement_expression : '--' unary_expression ;
	[GrammarRule("pre_decrement_expression")]
	public csParser.pre_decrement_expression_return pre_decrement_expression()
	{
		Enter_pre_decrement_expression();
		EnterRule("pre_decrement_expression", 95);
		TraceIn("pre_decrement_expression", 95);
		csParser.pre_decrement_expression_return retval = new csParser.pre_decrement_expression_return();
		retval.Start = (IToken)input.LT(1);
		int pre_decrement_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal366=null;
		csParser.unary_expression_return unary_expression367 = default(csParser.unary_expression_return);

		object string_literal366_tree=null;

		try { DebugEnterRule(GrammarFileName, "pre_decrement_expression");
		DebugLocation(397, 25);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 95)) { return retval; }
			// cs.g:397:32: ( '--' unary_expression )
			DebugEnterAlt(1);
			// cs.g:398:2: '--' unary_expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(398, 2);
			string_literal366=(IToken)Match(input,87,Follow._87_in_pre_decrement_expression3029); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal366_tree = (object)adaptor.Create(string_literal366);
			adaptor.AddChild(root_0, string_literal366_tree);
			}
			DebugLocation(398, 9);
			PushFollow(Follow._unary_expression_in_pre_decrement_expression3033);
			unary_expression367=unary_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression367.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("pre_decrement_expression", 95);
			LeaveRule("pre_decrement_expression", 95);
			Leave_pre_decrement_expression();
			if (state.backtracking > 0) { Memoize(input, 95, pre_decrement_expression_StartIndex); }
		}
		DebugLocation(398, 25);
		} finally { DebugExitRule(GrammarFileName, "pre_decrement_expression"); }
		return retval;

	}
	// $ANTLR end "pre_decrement_expression"

	public class pointer_indirection_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_pointer_indirection_expression();
	partial void Leave_pointer_indirection_expression();

	// $ANTLR start "pointer_indirection_expression"
	// cs.g:399:8: public pointer_indirection_expression : '*' unary_expression ;
	[GrammarRule("pointer_indirection_expression")]
	public csParser.pointer_indirection_expression_return pointer_indirection_expression()
	{
		Enter_pointer_indirection_expression();
		EnterRule("pointer_indirection_expression", 96);
		TraceIn("pointer_indirection_expression", 96);
		csParser.pointer_indirection_expression_return retval = new csParser.pointer_indirection_expression_return();
		retval.Start = (IToken)input.LT(1);
		int pointer_indirection_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal368=null;
		csParser.unary_expression_return unary_expression369 = default(csParser.unary_expression_return);

		object char_literal368_tree=null;

		try { DebugEnterRule(GrammarFileName, "pointer_indirection_expression");
		DebugLocation(399, 24);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 96)) { return retval; }
			// cs.g:399:38: ( '*' unary_expression )
			DebugEnterAlt(1);
			// cs.g:400:2: '*' unary_expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(400, 2);
			char_literal368=(IToken)Match(input,102,Follow._102_in_pointer_indirection_expression3043); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal368_tree = (object)adaptor.Create(char_literal368);
			adaptor.AddChild(root_0, char_literal368_tree);
			}
			DebugLocation(400, 8);
			PushFollow(Follow._unary_expression_in_pointer_indirection_expression3047);
			unary_expression369=unary_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression369.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("pointer_indirection_expression", 96);
			LeaveRule("pointer_indirection_expression", 96);
			Leave_pointer_indirection_expression();
			if (state.backtracking > 0) { Memoize(input, 96, pointer_indirection_expression_StartIndex); }
		}
		DebugLocation(400, 24);
		} finally { DebugExitRule(GrammarFileName, "pointer_indirection_expression"); }
		return retval;

	}
	// $ANTLR end "pointer_indirection_expression"

	public class addressof_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_addressof_expression();
	partial void Leave_addressof_expression();

	// $ANTLR start "addressof_expression"
	// cs.g:401:8: public addressof_expression : '&' unary_expression ;
	[GrammarRule("addressof_expression")]
	public csParser.addressof_expression_return addressof_expression()
	{
		Enter_addressof_expression();
		EnterRule("addressof_expression", 97);
		TraceIn("addressof_expression", 97);
		csParser.addressof_expression_return retval = new csParser.addressof_expression_return();
		retval.Start = (IToken)input.LT(1);
		int addressof_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal370=null;
		csParser.unary_expression_return unary_expression371 = default(csParser.unary_expression_return);

		object char_literal370_tree=null;

		try { DebugEnterRule(GrammarFileName, "addressof_expression");
		DebugLocation(401, 24);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 97)) { return retval; }
			// cs.g:401:28: ( '&' unary_expression )
			DebugEnterAlt(1);
			// cs.g:402:2: '&' unary_expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(402, 2);
			char_literal370=(IToken)Match(input,117,Follow._117_in_addressof_expression3057); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal370_tree = (object)adaptor.Create(char_literal370);
			adaptor.AddChild(root_0, char_literal370_tree);
			}
			DebugLocation(402, 8);
			PushFollow(Follow._unary_expression_in_addressof_expression3061);
			unary_expression371=unary_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression371.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("addressof_expression", 97);
			LeaveRule("addressof_expression", 97);
			Leave_addressof_expression();
			if (state.backtracking > 0) { Memoize(input, 97, addressof_expression_StartIndex); }
		}
		DebugLocation(402, 24);
		} finally { DebugExitRule(GrammarFileName, "addressof_expression"); }
		return retval;

	}
	// $ANTLR end "addressof_expression"

	public class non_assignment_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_non_assignment_expression();
	partial void Leave_non_assignment_expression();

	// $ANTLR start "non_assignment_expression"
	// cs.g:404:8: public non_assignment_expression : ( ( anonymous_function_signature '=>' )=> lambda_expression | ( query_expression )=> query_expression | conditional_expression );
	[GrammarRule("non_assignment_expression")]
	public csParser.non_assignment_expression_return non_assignment_expression()
	{
		Enter_non_assignment_expression();
		EnterRule("non_assignment_expression", 98);
		TraceIn("non_assignment_expression", 98);
		csParser.non_assignment_expression_return retval = new csParser.non_assignment_expression_return();
		retval.Start = (IToken)input.LT(1);
		int non_assignment_expression_StartIndex = input.Index;
		object root_0 = null;

		csParser.lambda_expression_return lambda_expression372 = default(csParser.lambda_expression_return);
		csParser.query_expression_return query_expression373 = default(csParser.query_expression_return);
		csParser.conditional_expression_return conditional_expression374 = default(csParser.conditional_expression_return);


		try { DebugEnterRule(GrammarFileName, "non_assignment_expression");
		DebugLocation(404, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 98)) { return retval; }
			// cs.g:404:33: ( ( anonymous_function_signature '=>' )=> lambda_expression | ( query_expression )=> query_expression | conditional_expression )
			int alt105=3;
			try { DebugEnterDecision(105, decisionCanBacktrack[105]);
			try
			{
				alt105 = dfa105.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(105); }
			switch (alt105)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:406:2: ( anonymous_function_signature '=>' )=> lambda_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(406, 43);
				PushFollow(Follow._lambda_expression_in_non_assignment_expression3084);
				lambda_expression372=lambda_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, lambda_expression372.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:407:4: ( query_expression )=> query_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(407, 26);
				PushFollow(Follow._query_expression_in_non_assignment_expression3095);
				query_expression373=query_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_expression373.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:408:4: conditional_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(408, 4);
				PushFollow(Follow._conditional_expression_in_non_assignment_expression3101);
				conditional_expression374=conditional_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_expression374.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("non_assignment_expression", 98);
			LeaveRule("non_assignment_expression", 98);
			Leave_non_assignment_expression();
			if (state.backtracking > 0) { Memoize(input, 98, non_assignment_expression_StartIndex); }
		}
		DebugLocation(409, 1);
		} finally { DebugExitRule(GrammarFileName, "non_assignment_expression"); }
		return retval;

	}
	// $ANTLR end "non_assignment_expression"

	public class multiplicative_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_multiplicative_expression();
	partial void Leave_multiplicative_expression();

	// $ANTLR start "multiplicative_expression"
	// cs.g:415:8: public multiplicative_expression : unary_expression ( ( '*' | '/' | '%' ) unary_expression )* ;
	[GrammarRule("multiplicative_expression")]
	public csParser.multiplicative_expression_return multiplicative_expression()
	{
		Enter_multiplicative_expression();
		EnterRule("multiplicative_expression", 99);
		TraceIn("multiplicative_expression", 99);
		csParser.multiplicative_expression_return retval = new csParser.multiplicative_expression_return();
		retval.Start = (IToken)input.LT(1);
		int multiplicative_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken set376=null;
		csParser.unary_expression_return unary_expression375 = default(csParser.unary_expression_return);
		csParser.unary_expression_return unary_expression377 = default(csParser.unary_expression_return);

		object set376_tree=null;

		try { DebugEnterRule(GrammarFileName, "multiplicative_expression");
		DebugLocation(415, 56);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 99)) { return retval; }
			// cs.g:415:33: ( unary_expression ( ( '*' | '/' | '%' ) unary_expression )* )
			DebugEnterAlt(1);
			// cs.g:416:2: unary_expression ( ( '*' | '/' | '%' ) unary_expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(416, 2);
			PushFollow(Follow._unary_expression_in_multiplicative_expression3117);
			unary_expression375=unary_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression375.Tree);
			DebugLocation(416, 19);
			// cs.g:416:19: ( ( '*' | '/' | '%' ) unary_expression )*
			try { DebugEnterSubRule(106);
			while (true)
			{
				int alt106=2;
				try { DebugEnterDecision(106, decisionCanBacktrack[106]);
				int LA106_0 = input.LA(1);

				if ((LA106_0==102||(LA106_0>=118 && LA106_0<=119)))
				{
					alt106=1;
				}


				} finally { DebugExitDecision(106); }
				switch ( alt106 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:416:22: ( '*' | '/' | '%' ) unary_expression
					{
					DebugLocation(416, 22);
					set376=(IToken)input.LT(1);
					if (input.LA(1)==102||(input.LA(1)>=118 && input.LA(1)<=119))
					{
						input.Consume();
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set376));
						state.errorRecovery=false;state.failed=false;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						DebugRecognitionException(mse);
						throw mse;
					}

					DebugLocation(416, 38);
					PushFollow(Follow._unary_expression_in_multiplicative_expression3132);
					unary_expression377=unary_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression377.Tree);

					}
					break;

				default:
					goto loop106;
				}
			}

			loop106:
				;

			} finally { DebugExitSubRule(106); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("multiplicative_expression", 99);
			LeaveRule("multiplicative_expression", 99);
			Leave_multiplicative_expression();
			if (state.backtracking > 0) { Memoize(input, 99, multiplicative_expression_StartIndex); }
		}
		DebugLocation(416, 56);
		} finally { DebugExitRule(GrammarFileName, "multiplicative_expression"); }
		return retval;

	}
	// $ANTLR end "multiplicative_expression"

	public class additive_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_additive_expression();
	partial void Leave_additive_expression();

	// $ANTLR start "additive_expression"
	// cs.g:417:8: public additive_expression : multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )* ;
	[GrammarRule("additive_expression")]
	public csParser.additive_expression_return additive_expression()
	{
		Enter_additive_expression();
		EnterRule("additive_expression", 100);
		TraceIn("additive_expression", 100);
		csParser.additive_expression_return retval = new csParser.additive_expression_return();
		retval.Start = (IToken)input.LT(1);
		int additive_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken set379=null;
		csParser.multiplicative_expression_return multiplicative_expression378 = default(csParser.multiplicative_expression_return);
		csParser.multiplicative_expression_return multiplicative_expression380 = default(csParser.multiplicative_expression_return);

		object set379_tree=null;

		try { DebugEnterRule(GrammarFileName, "additive_expression");
		DebugLocation(417, 68);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 100)) { return retval; }
			// cs.g:417:27: ( multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )* )
			DebugEnterAlt(1);
			// cs.g:418:2: multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(418, 2);
			PushFollow(Follow._multiplicative_expression_in_additive_expression3144);
			multiplicative_expression378=multiplicative_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, multiplicative_expression378.Tree);
			DebugLocation(418, 28);
			// cs.g:418:28: ( ( '+' | '-' ) multiplicative_expression )*
			try { DebugEnterSubRule(107);
			while (true)
			{
				int alt107=2;
				try { DebugEnterDecision(107, decisionCanBacktrack[107]);
				int LA107_0 = input.LA(1);

				if ((LA107_0==MINUS||LA107_0==104))
				{
					alt107=1;
				}


				} finally { DebugExitDecision(107); }
				switch ( alt107 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:418:29: ( '+' | '-' ) multiplicative_expression
					{
					DebugLocation(418, 29);
					set379=(IToken)input.LT(1);
					if (input.LA(1)==MINUS||input.LA(1)==104)
					{
						input.Consume();
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set379));
						state.errorRecovery=false;state.failed=false;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						DebugRecognitionException(mse);
						throw mse;
					}

					DebugLocation(418, 41);
					PushFollow(Follow._multiplicative_expression_in_additive_expression3155);
					multiplicative_expression380=multiplicative_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, multiplicative_expression380.Tree);

					}
					break;

				default:
					goto loop107;
				}
			}

			loop107:
				;

			} finally { DebugExitSubRule(107); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("additive_expression", 100);
			LeaveRule("additive_expression", 100);
			Leave_additive_expression();
			if (state.backtracking > 0) { Memoize(input, 100, additive_expression_StartIndex); }
		}
		DebugLocation(418, 68);
		} finally { DebugExitRule(GrammarFileName, "additive_expression"); }
		return retval;

	}
	// $ANTLR end "additive_expression"

	public class shift_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_shift_expression();
	partial void Leave_shift_expression();

	// $ANTLR start "shift_expression"
	// cs.g:420:8: public shift_expression : additive_expression ( ( '<<' | '>' '>' ) additive_expression )* ;
	[GrammarRule("shift_expression")]
	public csParser.shift_expression_return shift_expression()
	{
		Enter_shift_expression();
		EnterRule("shift_expression", 101);
		TraceIn("shift_expression", 101);
		csParser.shift_expression_return retval = new csParser.shift_expression_return();
		retval.Start = (IToken)input.LT(1);
		int shift_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal382=null;
		IToken char_literal383=null;
		IToken char_literal384=null;
		csParser.additive_expression_return additive_expression381 = default(csParser.additive_expression_return);
		csParser.additive_expression_return additive_expression385 = default(csParser.additive_expression_return);

		object string_literal382_tree=null;
		object char_literal383_tree=null;
		object char_literal384_tree=null;

		try { DebugEnterRule(GrammarFileName, "shift_expression");
		DebugLocation(420, 59);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 101)) { return retval; }
			// cs.g:420:24: ( additive_expression ( ( '<<' | '>' '>' ) additive_expression )* )
			DebugEnterAlt(1);
			// cs.g:421:2: additive_expression ( ( '<<' | '>' '>' ) additive_expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(421, 2);
			PushFollow(Follow._additive_expression_in_shift_expression3168);
			additive_expression381=additive_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, additive_expression381.Tree);
			DebugLocation(421, 22);
			// cs.g:421:22: ( ( '<<' | '>' '>' ) additive_expression )*
			try { DebugEnterSubRule(109);
			while (true)
			{
				int alt109=2;
				try { DebugEnterDecision(109, decisionCanBacktrack[109]);
				int LA109_0 = input.LA(1);

				if ((LA109_0==GT))
				{
					int LA109_1 = input.LA(2);

					if ((LA109_1==GT))
					{
						alt109=1;
					}


				}
				else if ((LA109_0==120))
				{
					alt109=1;
				}


				} finally { DebugExitDecision(109); }
				switch ( alt109 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:421:23: ( '<<' | '>' '>' ) additive_expression
					{
					DebugLocation(421, 23);
					// cs.g:421:23: ( '<<' | '>' '>' )
					int alt108=2;
					try { DebugEnterSubRule(108);
					try { DebugEnterDecision(108, decisionCanBacktrack[108]);
					int LA108_0 = input.LA(1);

					if ((LA108_0==120))
					{
						alt108=1;
					}
					else if ((LA108_0==GT))
					{
						alt108=2;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 108, 0, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
					} finally { DebugExitDecision(108); }
					switch (alt108)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:421:24: '<<'
						{
						DebugLocation(421, 24);
						string_literal382=(IToken)Match(input,120,Follow._120_in_shift_expression3172); if (state.failed) return retval;
						if ( state.backtracking==0 ) {
						string_literal382_tree = (object)adaptor.Create(string_literal382);
						adaptor.AddChild(root_0, string_literal382_tree);
						}

						}
						break;
					case 2:
						DebugEnterAlt(2);
						// cs.g:421:29: '>' '>'
						{
						DebugLocation(421, 29);
						char_literal383=(IToken)Match(input,GT,Follow._GT_in_shift_expression3174); if (state.failed) return retval;
						if ( state.backtracking==0 ) {
						char_literal383_tree = (object)adaptor.Create(char_literal383);
						adaptor.AddChild(root_0, char_literal383_tree);
						}
						DebugLocation(421, 33);
						char_literal384=(IToken)Match(input,GT,Follow._GT_in_shift_expression3176); if (state.failed) return retval;
						if ( state.backtracking==0 ) {
						char_literal384_tree = (object)adaptor.Create(char_literal384);
						adaptor.AddChild(root_0, char_literal384_tree);
						}

						}
						break;

					}
					} finally { DebugExitSubRule(108); }

					DebugLocation(421, 38);
					PushFollow(Follow._additive_expression_in_shift_expression3179);
					additive_expression385=additive_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, additive_expression385.Tree);

					}
					break;

				default:
					goto loop109;
				}
			}

			loop109:
				;

			} finally { DebugExitSubRule(109); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("shift_expression", 101);
			LeaveRule("shift_expression", 101);
			Leave_shift_expression();
			if (state.backtracking > 0) { Memoize(input, 101, shift_expression_StartIndex); }
		}
		DebugLocation(421, 59);
		} finally { DebugExitRule(GrammarFileName, "shift_expression"); }
		return retval;

	}
	// $ANTLR end "shift_expression"

	public class relational_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_relational_expression();
	partial void Leave_relational_expression();

	// $ANTLR start "relational_expression"
	// cs.g:422:8: public relational_expression : shift_expression ( ( ( '<' | '>' | '>=' | '<=' ) shift_expression ) | ( ( 'is' | 'as' ) non_nullable_type ) )* ;
	[GrammarRule("relational_expression")]
	public csParser.relational_expression_return relational_expression()
	{
		Enter_relational_expression();
		EnterRule("relational_expression", 102);
		TraceIn("relational_expression", 102);
		csParser.relational_expression_return retval = new csParser.relational_expression_return();
		retval.Start = (IToken)input.LT(1);
		int relational_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken set387=null;
		IToken set389=null;
		csParser.shift_expression_return shift_expression386 = default(csParser.shift_expression_return);
		csParser.shift_expression_return shift_expression388 = default(csParser.shift_expression_return);
		csParser.non_nullable_type_return non_nullable_type390 = default(csParser.non_nullable_type_return);

		object set387_tree=null;
		object set389_tree=null;

		try { DebugEnterRule(GrammarFileName, "relational_expression");
		DebugLocation(422, 5);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 102)) { return retval; }
			// cs.g:422:29: ( shift_expression ( ( ( '<' | '>' | '>=' | '<=' ) shift_expression ) | ( ( 'is' | 'as' ) non_nullable_type ) )* )
			DebugEnterAlt(1);
			// cs.g:423:2: shift_expression ( ( ( '<' | '>' | '>=' | '<=' ) shift_expression ) | ( ( 'is' | 'as' ) non_nullable_type ) )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(423, 2);
			PushFollow(Follow._shift_expression_in_relational_expression3191);
			shift_expression386=shift_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, shift_expression386.Tree);
			DebugLocation(424, 3);
			// cs.g:424:3: ( ( ( '<' | '>' | '>=' | '<=' ) shift_expression ) | ( ( 'is' | 'as' ) non_nullable_type ) )*
			try { DebugEnterSubRule(110);
			while (true)
			{
				int alt110=3;
				try { DebugEnterDecision(110, decisionCanBacktrack[110]);
				int LA110_0 = input.LA(1);

				if ((LA110_0==GT||LA110_0==101||LA110_0==116||LA110_0==121))
				{
					alt110=1;
				}
				else if (((LA110_0>=122 && LA110_0<=123)))
				{
					alt110=2;
				}


				} finally { DebugExitDecision(110); }
				switch ( alt110 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:424:5: ( ( '<' | '>' | '>=' | '<=' ) shift_expression )
					{
					DebugLocation(424, 5);
					// cs.g:424:5: ( ( '<' | '>' | '>=' | '<=' ) shift_expression )
					DebugEnterAlt(1);
					// cs.g:424:6: ( '<' | '>' | '>=' | '<=' ) shift_expression
					{
					DebugLocation(424, 6);
					set387=(IToken)input.LT(1);
					if (input.LA(1)==GT||input.LA(1)==101||input.LA(1)==116||input.LA(1)==121)
					{
						input.Consume();
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set387));
						state.errorRecovery=false;state.failed=false;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						DebugRecognitionException(mse);
						throw mse;
					}

					DebugLocation(424, 26);
					PushFollow(Follow._shift_expression_in_relational_expression3208);
					shift_expression388=shift_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, shift_expression388.Tree);

					}


					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:425:6: ( ( 'is' | 'as' ) non_nullable_type )
					{
					DebugLocation(425, 6);
					// cs.g:425:6: ( ( 'is' | 'as' ) non_nullable_type )
					DebugEnterAlt(1);
					// cs.g:425:7: ( 'is' | 'as' ) non_nullable_type
					{
					DebugLocation(425, 7);
					set389=(IToken)input.LT(1);
					if ((input.LA(1)>=122 && input.LA(1)<=123))
					{
						input.Consume();
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set389));
						state.errorRecovery=false;state.failed=false;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						DebugRecognitionException(mse);
						throw mse;
					}

					DebugLocation(425, 21);
					PushFollow(Follow._non_nullable_type_in_relational_expression3225);
					non_nullable_type390=non_nullable_type();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, non_nullable_type390.Tree);

					}


					}
					break;

				default:
					goto loop110;
				}
			}

			loop110:
				;

			} finally { DebugExitSubRule(110); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("relational_expression", 102);
			LeaveRule("relational_expression", 102);
			Leave_relational_expression();
			if (state.backtracking > 0) { Memoize(input, 102, relational_expression_StartIndex); }
		}
		DebugLocation(426, 5);
		} finally { DebugExitRule(GrammarFileName, "relational_expression"); }
		return retval;

	}
	// $ANTLR end "relational_expression"

	public class equality_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_equality_expression();
	partial void Leave_equality_expression();

	// $ANTLR start "equality_expression"
	// cs.g:427:8: public equality_expression : relational_expression ( ( '==' | '!=' ) relational_expression )* ;
	[GrammarRule("equality_expression")]
	public csParser.equality_expression_return equality_expression()
	{
		Enter_equality_expression();
		EnterRule("equality_expression", 103);
		TraceIn("equality_expression", 103);
		csParser.equality_expression_return retval = new csParser.equality_expression_return();
		retval.Start = (IToken)input.LT(1);
		int equality_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken set392=null;
		csParser.relational_expression_return relational_expression391 = default(csParser.relational_expression_return);
		csParser.relational_expression_return relational_expression393 = default(csParser.relational_expression_return);

		object set392_tree=null;

		try { DebugEnterRule(GrammarFileName, "equality_expression");
		DebugLocation(427, 43);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 103)) { return retval; }
			// cs.g:427:27: ( relational_expression ( ( '==' | '!=' ) relational_expression )* )
			DebugEnterAlt(1);
			// cs.g:428:2: relational_expression ( ( '==' | '!=' ) relational_expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(428, 2);
			PushFollow(Follow._relational_expression_in_equality_expression3241);
			relational_expression391=relational_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, relational_expression391.Tree);
			DebugLocation(429, 5);
			// cs.g:429:5: ( ( '==' | '!=' ) relational_expression )*
			try { DebugEnterSubRule(111);
			while (true)
			{
				int alt111=2;
				try { DebugEnterDecision(111, decisionCanBacktrack[111]);
				int LA111_0 = input.LA(1);

				if (((LA111_0>=124 && LA111_0<=125)))
				{
					alt111=1;
				}


				} finally { DebugExitDecision(111); }
				switch ( alt111 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:429:6: ( '==' | '!=' ) relational_expression
					{
					DebugLocation(429, 6);
					set392=(IToken)input.LT(1);
					if ((input.LA(1)>=124 && input.LA(1)<=125))
					{
						input.Consume();
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set392));
						state.errorRecovery=false;state.failed=false;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						DebugRecognitionException(mse);
						throw mse;
					}

					DebugLocation(429, 20);
					PushFollow(Follow._relational_expression_in_equality_expression3256);
					relational_expression393=relational_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, relational_expression393.Tree);

					}
					break;

				default:
					goto loop111;
				}
			}

			loop111:
				;

			} finally { DebugExitSubRule(111); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("equality_expression", 103);
			LeaveRule("equality_expression", 103);
			Leave_equality_expression();
			if (state.backtracking > 0) { Memoize(input, 103, equality_expression_StartIndex); }
		}
		DebugLocation(429, 43);
		} finally { DebugExitRule(GrammarFileName, "equality_expression"); }
		return retval;

	}
	// $ANTLR end "equality_expression"

	public class and_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_and_expression();
	partial void Leave_and_expression();

	// $ANTLR start "and_expression"
	// cs.g:430:8: public and_expression : equality_expression ( '&' equality_expression )* ;
	[GrammarRule("and_expression")]
	public csParser.and_expression_return and_expression()
	{
		Enter_and_expression();
		EnterRule("and_expression", 104);
		TraceIn("and_expression", 104);
		csParser.and_expression_return retval = new csParser.and_expression_return();
		retval.Start = (IToken)input.LT(1);
		int and_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal395=null;
		csParser.equality_expression_return equality_expression394 = default(csParser.equality_expression_return);
		csParser.equality_expression_return equality_expression396 = default(csParser.equality_expression_return);

		object char_literal395_tree=null;

		try { DebugEnterRule(GrammarFileName, "and_expression");
		DebugLocation(430, 50);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 104)) { return retval; }
			// cs.g:430:22: ( equality_expression ( '&' equality_expression )* )
			DebugEnterAlt(1);
			// cs.g:431:2: equality_expression ( '&' equality_expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(431, 2);
			PushFollow(Follow._equality_expression_in_and_expression3268);
			equality_expression394=equality_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, equality_expression394.Tree);
			DebugLocation(431, 22);
			// cs.g:431:22: ( '&' equality_expression )*
			try { DebugEnterSubRule(112);
			while (true)
			{
				int alt112=2;
				try { DebugEnterDecision(112, decisionCanBacktrack[112]);
				int LA112_0 = input.LA(1);

				if ((LA112_0==117))
				{
					alt112=1;
				}


				} finally { DebugExitDecision(112); }
				switch ( alt112 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:431:23: '&' equality_expression
					{
					DebugLocation(431, 23);
					char_literal395=(IToken)Match(input,117,Follow._117_in_and_expression3271); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal395_tree = (object)adaptor.Create(char_literal395);
					adaptor.AddChild(root_0, char_literal395_tree);
					}
					DebugLocation(431, 29);
					PushFollow(Follow._equality_expression_in_and_expression3275);
					equality_expression396=equality_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, equality_expression396.Tree);

					}
					break;

				default:
					goto loop112;
				}
			}

			loop112:
				;

			} finally { DebugExitSubRule(112); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("and_expression", 104);
			LeaveRule("and_expression", 104);
			Leave_and_expression();
			if (state.backtracking > 0) { Memoize(input, 104, and_expression_StartIndex); }
		}
		DebugLocation(431, 50);
		} finally { DebugExitRule(GrammarFileName, "and_expression"); }
		return retval;

	}
	// $ANTLR end "and_expression"

	public class exclusive_or_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_exclusive_or_expression();
	partial void Leave_exclusive_or_expression();

	// $ANTLR start "exclusive_or_expression"
	// cs.g:432:8: public exclusive_or_expression : and_expression ( '^' and_expression )* ;
	[GrammarRule("exclusive_or_expression")]
	public csParser.exclusive_or_expression_return exclusive_or_expression()
	{
		Enter_exclusive_or_expression();
		EnterRule("exclusive_or_expression", 105);
		TraceIn("exclusive_or_expression", 105);
		csParser.exclusive_or_expression_return retval = new csParser.exclusive_or_expression_return();
		retval.Start = (IToken)input.LT(1);
		int exclusive_or_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal398=null;
		csParser.and_expression_return and_expression397 = default(csParser.and_expression_return);
		csParser.and_expression_return and_expression399 = default(csParser.and_expression_return);

		object char_literal398_tree=null;

		try { DebugEnterRule(GrammarFileName, "exclusive_or_expression");
		DebugLocation(432, 40);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 105)) { return retval; }
			// cs.g:432:31: ( and_expression ( '^' and_expression )* )
			DebugEnterAlt(1);
			// cs.g:433:2: and_expression ( '^' and_expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(433, 2);
			PushFollow(Follow._and_expression_in_exclusive_or_expression3287);
			and_expression397=and_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, and_expression397.Tree);
			DebugLocation(433, 17);
			// cs.g:433:17: ( '^' and_expression )*
			try { DebugEnterSubRule(113);
			while (true)
			{
				int alt113=2;
				try { DebugEnterDecision(113, decisionCanBacktrack[113]);
				int LA113_0 = input.LA(1);

				if ((LA113_0==126))
				{
					alt113=1;
				}


				} finally { DebugExitDecision(113); }
				switch ( alt113 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:433:18: '^' and_expression
					{
					DebugLocation(433, 18);
					char_literal398=(IToken)Match(input,126,Follow._126_in_exclusive_or_expression3290); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal398_tree = (object)adaptor.Create(char_literal398);
					adaptor.AddChild(root_0, char_literal398_tree);
					}
					DebugLocation(433, 24);
					PushFollow(Follow._and_expression_in_exclusive_or_expression3294);
					and_expression399=and_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, and_expression399.Tree);

					}
					break;

				default:
					goto loop113;
				}
			}

			loop113:
				;

			} finally { DebugExitSubRule(113); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("exclusive_or_expression", 105);
			LeaveRule("exclusive_or_expression", 105);
			Leave_exclusive_or_expression();
			if (state.backtracking > 0) { Memoize(input, 105, exclusive_or_expression_StartIndex); }
		}
		DebugLocation(433, 40);
		} finally { DebugExitRule(GrammarFileName, "exclusive_or_expression"); }
		return retval;

	}
	// $ANTLR end "exclusive_or_expression"

	public class inclusive_or_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_inclusive_or_expression();
	partial void Leave_inclusive_or_expression();

	// $ANTLR start "inclusive_or_expression"
	// cs.g:434:8: public inclusive_or_expression : exclusive_or_expression ( '|' exclusive_or_expression )* ;
	[GrammarRule("inclusive_or_expression")]
	public csParser.inclusive_or_expression_return inclusive_or_expression()
	{
		Enter_inclusive_or_expression();
		EnterRule("inclusive_or_expression", 106);
		TraceIn("inclusive_or_expression", 106);
		csParser.inclusive_or_expression_return retval = new csParser.inclusive_or_expression_return();
		retval.Start = (IToken)input.LT(1);
		int inclusive_or_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal401=null;
		csParser.exclusive_or_expression_return exclusive_or_expression400 = default(csParser.exclusive_or_expression_return);
		csParser.exclusive_or_expression_return exclusive_or_expression402 = default(csParser.exclusive_or_expression_return);

		object char_literal401_tree=null;

		try { DebugEnterRule(GrammarFileName, "inclusive_or_expression");
		DebugLocation(434, 60);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 106)) { return retval; }
			// cs.g:434:31: ( exclusive_or_expression ( '|' exclusive_or_expression )* )
			DebugEnterAlt(1);
			// cs.g:435:2: exclusive_or_expression ( '|' exclusive_or_expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(435, 2);
			PushFollow(Follow._exclusive_or_expression_in_inclusive_or_expression3306);
			exclusive_or_expression400=exclusive_or_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, exclusive_or_expression400.Tree);
			DebugLocation(435, 28);
			// cs.g:435:28: ( '|' exclusive_or_expression )*
			try { DebugEnterSubRule(114);
			while (true)
			{
				int alt114=2;
				try { DebugEnterDecision(114, decisionCanBacktrack[114]);
				int LA114_0 = input.LA(1);

				if ((LA114_0==127))
				{
					alt114=1;
				}


				} finally { DebugExitDecision(114); }
				switch ( alt114 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:435:29: '|' exclusive_or_expression
					{
					DebugLocation(435, 29);
					char_literal401=(IToken)Match(input,127,Follow._127_in_inclusive_or_expression3311); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal401_tree = (object)adaptor.Create(char_literal401);
					adaptor.AddChild(root_0, char_literal401_tree);
					}
					DebugLocation(435, 35);
					PushFollow(Follow._exclusive_or_expression_in_inclusive_or_expression3315);
					exclusive_or_expression402=exclusive_or_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, exclusive_or_expression402.Tree);

					}
					break;

				default:
					goto loop114;
				}
			}

			loop114:
				;

			} finally { DebugExitSubRule(114); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("inclusive_or_expression", 106);
			LeaveRule("inclusive_or_expression", 106);
			Leave_inclusive_or_expression();
			if (state.backtracking > 0) { Memoize(input, 106, inclusive_or_expression_StartIndex); }
		}
		DebugLocation(435, 60);
		} finally { DebugExitRule(GrammarFileName, "inclusive_or_expression"); }
		return retval;

	}
	// $ANTLR end "inclusive_or_expression"

	public class conditional_and_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_conditional_and_expression();
	partial void Leave_conditional_and_expression();

	// $ANTLR start "conditional_and_expression"
	// cs.g:436:8: public conditional_and_expression : inclusive_or_expression ( '&&' inclusive_or_expression )* ;
	[GrammarRule("conditional_and_expression")]
	public csParser.conditional_and_expression_return conditional_and_expression()
	{
		Enter_conditional_and_expression();
		EnterRule("conditional_and_expression", 107);
		TraceIn("conditional_and_expression", 107);
		csParser.conditional_and_expression_return retval = new csParser.conditional_and_expression_return();
		retval.Start = (IToken)input.LT(1);
		int conditional_and_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal404=null;
		csParser.inclusive_or_expression_return inclusive_or_expression403 = default(csParser.inclusive_or_expression_return);
		csParser.inclusive_or_expression_return inclusive_or_expression405 = default(csParser.inclusive_or_expression_return);

		object string_literal404_tree=null;

		try { DebugEnterRule(GrammarFileName, "conditional_and_expression");
		DebugLocation(436, 61);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 107)) { return retval; }
			// cs.g:436:34: ( inclusive_or_expression ( '&&' inclusive_or_expression )* )
			DebugEnterAlt(1);
			// cs.g:437:2: inclusive_or_expression ( '&&' inclusive_or_expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(437, 2);
			PushFollow(Follow._inclusive_or_expression_in_conditional_and_expression3327);
			inclusive_or_expression403=inclusive_or_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, inclusive_or_expression403.Tree);
			DebugLocation(437, 28);
			// cs.g:437:28: ( '&&' inclusive_or_expression )*
			try { DebugEnterSubRule(115);
			while (true)
			{
				int alt115=2;
				try { DebugEnterDecision(115, decisionCanBacktrack[115]);
				int LA115_0 = input.LA(1);

				if ((LA115_0==128))
				{
					alt115=1;
				}


				} finally { DebugExitDecision(115); }
				switch ( alt115 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:437:29: '&&' inclusive_or_expression
					{
					DebugLocation(437, 29);
					string_literal404=(IToken)Match(input,128,Follow._128_in_conditional_and_expression3332); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					string_literal404_tree = (object)adaptor.Create(string_literal404);
					adaptor.AddChild(root_0, string_literal404_tree);
					}
					DebugLocation(437, 36);
					PushFollow(Follow._inclusive_or_expression_in_conditional_and_expression3336);
					inclusive_or_expression405=inclusive_or_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, inclusive_or_expression405.Tree);

					}
					break;

				default:
					goto loop115;
				}
			}

			loop115:
				;

			} finally { DebugExitSubRule(115); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("conditional_and_expression", 107);
			LeaveRule("conditional_and_expression", 107);
			Leave_conditional_and_expression();
			if (state.backtracking > 0) { Memoize(input, 107, conditional_and_expression_StartIndex); }
		}
		DebugLocation(437, 61);
		} finally { DebugExitRule(GrammarFileName, "conditional_and_expression"); }
		return retval;

	}
	// $ANTLR end "conditional_and_expression"

	public class conditional_or_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_conditional_or_expression();
	partial void Leave_conditional_or_expression();

	// $ANTLR start "conditional_or_expression"
	// cs.g:438:8: public conditional_or_expression : conditional_and_expression ( '||' conditional_and_expression )* ;
	[GrammarRule("conditional_or_expression")]
	public csParser.conditional_or_expression_return conditional_or_expression()
	{
		Enter_conditional_or_expression();
		EnterRule("conditional_or_expression", 108);
		TraceIn("conditional_or_expression", 108);
		csParser.conditional_or_expression_return retval = new csParser.conditional_or_expression_return();
		retval.Start = (IToken)input.LT(1);
		int conditional_or_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal407=null;
		csParser.conditional_and_expression_return conditional_and_expression406 = default(csParser.conditional_and_expression_return);
		csParser.conditional_and_expression_return conditional_and_expression408 = default(csParser.conditional_and_expression_return);

		object string_literal407_tree=null;

		try { DebugEnterRule(GrammarFileName, "conditional_or_expression");
		DebugLocation(438, 66);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 108)) { return retval; }
			// cs.g:438:33: ( conditional_and_expression ( '||' conditional_and_expression )* )
			DebugEnterAlt(1);
			// cs.g:439:2: conditional_and_expression ( '||' conditional_and_expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(439, 2);
			PushFollow(Follow._conditional_and_expression_in_conditional_or_expression3348);
			conditional_and_expression406=conditional_and_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_and_expression406.Tree);
			DebugLocation(439, 30);
			// cs.g:439:30: ( '||' conditional_and_expression )*
			try { DebugEnterSubRule(116);
			while (true)
			{
				int alt116=2;
				try { DebugEnterDecision(116, decisionCanBacktrack[116]);
				int LA116_0 = input.LA(1);

				if ((LA116_0==129))
				{
					alt116=1;
				}


				} finally { DebugExitDecision(116); }
				switch ( alt116 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:439:31: '||' conditional_and_expression
					{
					DebugLocation(439, 31);
					string_literal407=(IToken)Match(input,129,Follow._129_in_conditional_or_expression3352); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					string_literal407_tree = (object)adaptor.Create(string_literal407);
					adaptor.AddChild(root_0, string_literal407_tree);
					}
					DebugLocation(439, 38);
					PushFollow(Follow._conditional_and_expression_in_conditional_or_expression3356);
					conditional_and_expression408=conditional_and_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_and_expression408.Tree);

					}
					break;

				default:
					goto loop116;
				}
			}

			loop116:
				;

			} finally { DebugExitSubRule(116); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("conditional_or_expression", 108);
			LeaveRule("conditional_or_expression", 108);
			Leave_conditional_or_expression();
			if (state.backtracking > 0) { Memoize(input, 108, conditional_or_expression_StartIndex); }
		}
		DebugLocation(439, 66);
		} finally { DebugExitRule(GrammarFileName, "conditional_or_expression"); }
		return retval;

	}
	// $ANTLR end "conditional_or_expression"

	public class null_coalescing_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_null_coalescing_expression();
	partial void Leave_null_coalescing_expression();

	// $ANTLR start "null_coalescing_expression"
	// cs.g:441:8: public null_coalescing_expression : conditional_or_expression ( '??' conditional_or_expression )* ;
	[GrammarRule("null_coalescing_expression")]
	public csParser.null_coalescing_expression_return null_coalescing_expression()
	{
		Enter_null_coalescing_expression();
		EnterRule("null_coalescing_expression", 109);
		TraceIn("null_coalescing_expression", 109);
		csParser.null_coalescing_expression_return retval = new csParser.null_coalescing_expression_return();
		retval.Start = (IToken)input.LT(1);
		int null_coalescing_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal410=null;
		csParser.conditional_or_expression_return conditional_or_expression409 = default(csParser.conditional_or_expression_return);
		csParser.conditional_or_expression_return conditional_or_expression411 = default(csParser.conditional_or_expression_return);

		object string_literal410_tree=null;

		try { DebugEnterRule(GrammarFileName, "null_coalescing_expression");
		DebugLocation(441, 65);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 109)) { return retval; }
			// cs.g:441:34: ( conditional_or_expression ( '??' conditional_or_expression )* )
			DebugEnterAlt(1);
			// cs.g:442:2: conditional_or_expression ( '??' conditional_or_expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(442, 2);
			PushFollow(Follow._conditional_or_expression_in_null_coalescing_expression3369);
			conditional_or_expression409=conditional_or_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_or_expression409.Tree);
			DebugLocation(442, 30);
			// cs.g:442:30: ( '??' conditional_or_expression )*
			try { DebugEnterSubRule(117);
			while (true)
			{
				int alt117=2;
				try { DebugEnterDecision(117, decisionCanBacktrack[117]);
				int LA117_0 = input.LA(1);

				if ((LA117_0==130))
				{
					alt117=1;
				}


				} finally { DebugExitDecision(117); }
				switch ( alt117 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:442:31: '??' conditional_or_expression
					{
					DebugLocation(442, 31);
					string_literal410=(IToken)Match(input,130,Follow._130_in_null_coalescing_expression3374); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					string_literal410_tree = (object)adaptor.Create(string_literal410);
					adaptor.AddChild(root_0, string_literal410_tree);
					}
					DebugLocation(442, 38);
					PushFollow(Follow._conditional_or_expression_in_null_coalescing_expression3378);
					conditional_or_expression411=conditional_or_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_or_expression411.Tree);

					}
					break;

				default:
					goto loop117;
				}
			}

			loop117:
				;

			} finally { DebugExitSubRule(117); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("null_coalescing_expression", 109);
			LeaveRule("null_coalescing_expression", 109);
			Leave_null_coalescing_expression();
			if (state.backtracking > 0) { Memoize(input, 109, null_coalescing_expression_StartIndex); }
		}
		DebugLocation(442, 65);
		} finally { DebugExitRule(GrammarFileName, "null_coalescing_expression"); }
		return retval;

	}
	// $ANTLR end "null_coalescing_expression"

	public class conditional_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_conditional_expression();
	partial void Leave_conditional_expression();

	// $ANTLR start "conditional_expression"
	// cs.g:443:8: public conditional_expression : null_coalescing_expression ( '?' expression ':' expression )? ;
	[GrammarRule("conditional_expression")]
	public csParser.conditional_expression_return conditional_expression()
	{
		Enter_conditional_expression();
		EnterRule("conditional_expression", 110);
		TraceIn("conditional_expression", 110);
		csParser.conditional_expression_return retval = new csParser.conditional_expression_return();
		retval.Start = (IToken)input.LT(1);
		int conditional_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal413=null;
		IToken char_literal415=null;
		csParser.null_coalescing_expression_return null_coalescing_expression412 = default(csParser.null_coalescing_expression_return);
		csParser.expression_return expression414 = default(csParser.expression_return);
		csParser.expression_return expression416 = default(csParser.expression_return);

		object char_literal413_tree=null;
		object char_literal415_tree=null;

		try { DebugEnterRule(GrammarFileName, "conditional_expression");
		DebugLocation(443, 69);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 110)) { return retval; }
			// cs.g:443:30: ( null_coalescing_expression ( '?' expression ':' expression )? )
			DebugEnterAlt(1);
			// cs.g:444:2: null_coalescing_expression ( '?' expression ':' expression )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(444, 2);
			PushFollow(Follow._null_coalescing_expression_in_conditional_expression3390);
			null_coalescing_expression412=null_coalescing_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, null_coalescing_expression412.Tree);
			DebugLocation(444, 31);
			// cs.g:444:31: ( '?' expression ':' expression )?
			int alt118=2;
			try { DebugEnterSubRule(118);
			try { DebugEnterDecision(118, decisionCanBacktrack[118]);
			int LA118_0 = input.LA(1);

			if ((LA118_0==103))
			{
				alt118=1;
			}
			} finally { DebugExitDecision(118); }
			switch (alt118)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:444:32: '?' expression ':' expression
				{
				DebugLocation(444, 32);
				char_literal413=(IToken)Match(input,103,Follow._103_in_conditional_expression3395); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal413_tree = (object)adaptor.Create(char_literal413);
				adaptor.AddChild(root_0, char_literal413_tree);
				}
				DebugLocation(444, 38);
				PushFollow(Follow._expression_in_conditional_expression3399);
				expression414=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression414.Tree);
				DebugLocation(444, 51);
				char_literal415=(IToken)Match(input,92,Follow._92_in_conditional_expression3403); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal415_tree = (object)adaptor.Create(char_literal415);
				adaptor.AddChild(root_0, char_literal415_tree);
				}
				DebugLocation(444, 57);
				PushFollow(Follow._expression_in_conditional_expression3407);
				expression416=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression416.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(118); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("conditional_expression", 110);
			LeaveRule("conditional_expression", 110);
			Leave_conditional_expression();
			if (state.backtracking > 0) { Memoize(input, 110, conditional_expression_StartIndex); }
		}
		DebugLocation(444, 69);
		} finally { DebugExitRule(GrammarFileName, "conditional_expression"); }
		return retval;

	}
	// $ANTLR end "conditional_expression"

	public class lambda_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_lambda_expression();
	partial void Leave_lambda_expression();

	// $ANTLR start "lambda_expression"
	// cs.g:449:8: public lambda_expression : anonymous_function_signature '=>' anonymous_function_body ;
	[GrammarRule("lambda_expression")]
	public csParser.lambda_expression_return lambda_expression()
	{
		Enter_lambda_expression();
		EnterRule("lambda_expression", 111);
		TraceIn("lambda_expression", 111);
		csParser.lambda_expression_return retval = new csParser.lambda_expression_return();
		retval.Start = (IToken)input.LT(1);
		int lambda_expression_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal418=null;
		csParser.anonymous_function_signature_return anonymous_function_signature417 = default(csParser.anonymous_function_signature_return);
		csParser.anonymous_function_body_return anonymous_function_body419 = default(csParser.anonymous_function_body_return);

		object string_literal418_tree=null;

		try { DebugEnterRule(GrammarFileName, "lambda_expression");
		DebugLocation(449, 62);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 111)) { return retval; }
			// cs.g:449:25: ( anonymous_function_signature '=>' anonymous_function_body )
			DebugEnterAlt(1);
			// cs.g:450:2: anonymous_function_signature '=>' anonymous_function_body
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(450, 2);
			PushFollow(Follow._anonymous_function_signature_in_lambda_expression3429);
			anonymous_function_signature417=anonymous_function_signature();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_function_signature417.Tree);
			DebugLocation(450, 33);
			string_literal418=(IToken)Match(input,131,Follow._131_in_lambda_expression3433); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal418_tree = (object)adaptor.Create(string_literal418);
			adaptor.AddChild(root_0, string_literal418_tree);
			}
			DebugLocation(450, 40);
			PushFollow(Follow._anonymous_function_body_in_lambda_expression3437);
			anonymous_function_body419=anonymous_function_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_function_body419.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("lambda_expression", 111);
			LeaveRule("lambda_expression", 111);
			Leave_lambda_expression();
			if (state.backtracking > 0) { Memoize(input, 111, lambda_expression_StartIndex); }
		}
		DebugLocation(450, 62);
		} finally { DebugExitRule(GrammarFileName, "lambda_expression"); }
		return retval;

	}
	// $ANTLR end "lambda_expression"

	public class anonymous_function_signature_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_anonymous_function_signature();
	partial void Leave_anonymous_function_signature();

	// $ANTLR start "anonymous_function_signature"
	// cs.g:451:8: public anonymous_function_signature : ( '(' ( explicit_anonymous_function_parameter_list | implicit_anonymous_function_parameter_list )? ')' | implicit_anonymous_function_parameter_list );
	[GrammarRule("anonymous_function_signature")]
	public csParser.anonymous_function_signature_return anonymous_function_signature()
	{
		Enter_anonymous_function_signature();
		EnterRule("anonymous_function_signature", 112);
		TraceIn("anonymous_function_signature", 112);
		csParser.anonymous_function_signature_return retval = new csParser.anonymous_function_signature_return();
		retval.Start = (IToken)input.LT(1);
		int anonymous_function_signature_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal420=null;
		IToken char_literal423=null;
		csParser.explicit_anonymous_function_parameter_list_return explicit_anonymous_function_parameter_list421 = default(csParser.explicit_anonymous_function_parameter_list_return);
		csParser.implicit_anonymous_function_parameter_list_return implicit_anonymous_function_parameter_list422 = default(csParser.implicit_anonymous_function_parameter_list_return);
		csParser.implicit_anonymous_function_parameter_list_return implicit_anonymous_function_parameter_list424 = default(csParser.implicit_anonymous_function_parameter_list_return);

		object char_literal420_tree=null;
		object char_literal423_tree=null;

		try { DebugEnterRule(GrammarFileName, "anonymous_function_signature");
		DebugLocation(451, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 112)) { return retval; }
			// cs.g:451:36: ( '(' ( explicit_anonymous_function_parameter_list | implicit_anonymous_function_parameter_list )? ')' | implicit_anonymous_function_parameter_list )
			int alt120=2;
			try { DebugEnterDecision(120, decisionCanBacktrack[120]);
			int LA120_0 = input.LA(1);

			if ((LA120_0==90))
			{
				alt120=1;
			}
			else if ((LA120_0==IDENTIFIER||(LA120_0>=ELIF && LA120_0<=UNDEF)||LA120_0==65||(LA120_0>=132 && LA120_0<=133)||(LA120_0>=135 && LA120_0<=148)||(LA120_0>=150 && LA120_0<=152)||LA120_0==154||(LA120_0>=156 && LA120_0<=159)||LA120_0==170||(LA120_0>=177 && LA120_0<=178)||LA120_0==195||LA120_0==202))
			{
				alt120=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 120, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(120); }
			switch (alt120)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:452:2: '(' ( explicit_anonymous_function_parameter_list | implicit_anonymous_function_parameter_list )? ')'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(452, 2);
				char_literal420=(IToken)Match(input,90,Follow._90_in_anonymous_function_signature3446); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal420_tree = (object)adaptor.Create(char_literal420);
				adaptor.AddChild(root_0, char_literal420_tree);
				}
				DebugLocation(452, 6);
				// cs.g:452:6: ( explicit_anonymous_function_parameter_list | implicit_anonymous_function_parameter_list )?
				int alt119=3;
				try { DebugEnterSubRule(119);
				try { DebugEnterDecision(119, decisionCanBacktrack[119]);
				switch (input.LA(1))
				{
				case 82:
				case 93:
				case 94:
				case 160:
				case 161:
				case 162:
				case 163:
				case 164:
				case 165:
				case 166:
				case 167:
				case 168:
				case 196:
				case 197:
				case 198:
				case 199:
				case 200:
				case 201:
					{
					alt119=1;
					}
					break;
				case IDENTIFIER:
					{
					int LA119_2 = input.LA(2);

					if ((LA119_2==IDENTIFIER||LA119_2==DOT||(LA119_2>=ELIF && LA119_2<=UNDEF)||LA119_2==65||LA119_2==85||LA119_2==88||(LA119_2>=101 && LA119_2<=103)||(LA119_2>=132 && LA119_2<=133)||(LA119_2>=135 && LA119_2<=148)||(LA119_2>=150 && LA119_2<=152)||LA119_2==154||(LA119_2>=156 && LA119_2<=159)||LA119_2==170||(LA119_2>=177 && LA119_2<=178)||LA119_2==195||LA119_2==202))
					{
						alt119=1;
					}
					else if ((LA119_2==RPAREN||LA119_2==91))
					{
						alt119=2;
					}
					}
					break;
				case ELIF:
				case ENDIF:
				case DEFINE:
				case UNDEF:
				case 65:
				case 132:
				case 133:
				case 135:
				case 136:
				case 137:
				case 138:
				case 139:
				case 140:
				case 141:
				case 142:
				case 143:
				case 144:
				case 145:
				case 146:
				case 147:
				case 148:
				case 150:
				case 151:
				case 152:
				case 154:
				case 156:
				case 157:
				case 158:
				case 159:
				case 170:
				case 177:
				case 178:
				case 195:
				case 202:
					{
					int LA119_3 = input.LA(2);

					if ((LA119_3==IDENTIFIER||LA119_3==DOT||(LA119_3>=ELIF && LA119_3<=UNDEF)||LA119_3==65||LA119_3==85||LA119_3==88||(LA119_3>=101 && LA119_3<=103)||(LA119_3>=132 && LA119_3<=133)||(LA119_3>=135 && LA119_3<=148)||(LA119_3>=150 && LA119_3<=152)||LA119_3==154||(LA119_3>=156 && LA119_3<=159)||LA119_3==170||(LA119_3>=177 && LA119_3<=178)||LA119_3==195||LA119_3==202))
					{
						alt119=1;
					}
					else if ((LA119_3==RPAREN||LA119_3==91))
					{
						alt119=2;
					}
					}
					break;
				}

				} finally { DebugExitDecision(119); }
				switch (alt119)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:452:7: explicit_anonymous_function_parameter_list
					{
					DebugLocation(452, 7);
					PushFollow(Follow._explicit_anonymous_function_parameter_list_in_anonymous_function_signature3449);
					explicit_anonymous_function_parameter_list421=explicit_anonymous_function_parameter_list();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, explicit_anonymous_function_parameter_list421.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:453:5: implicit_anonymous_function_parameter_list
					{
					DebugLocation(453, 5);
					PushFollow(Follow._implicit_anonymous_function_parameter_list_in_anonymous_function_signature3455);
					implicit_anonymous_function_parameter_list422=implicit_anonymous_function_parameter_list();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, implicit_anonymous_function_parameter_list422.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(119); }

				DebugLocation(453, 50);
				char_literal423=(IToken)Match(input,RPAREN,Follow._RPAREN_in_anonymous_function_signature3459); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal423_tree = (object)adaptor.Create(char_literal423);
				adaptor.AddChild(root_0, char_literal423_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:454:4: implicit_anonymous_function_parameter_list
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(454, 4);
				PushFollow(Follow._implicit_anonymous_function_parameter_list_in_anonymous_function_signature3464);
				implicit_anonymous_function_parameter_list424=implicit_anonymous_function_parameter_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, implicit_anonymous_function_parameter_list424.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("anonymous_function_signature", 112);
			LeaveRule("anonymous_function_signature", 112);
			Leave_anonymous_function_signature();
			if (state.backtracking > 0) { Memoize(input, 112, anonymous_function_signature_StartIndex); }
		}
		DebugLocation(455, 1);
		} finally { DebugExitRule(GrammarFileName, "anonymous_function_signature"); }
		return retval;

	}
	// $ANTLR end "anonymous_function_signature"

	public class implicit_anonymous_function_parameter_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_implicit_anonymous_function_parameter_list();
	partial void Leave_implicit_anonymous_function_parameter_list();

	// $ANTLR start "implicit_anonymous_function_parameter_list"
	// cs.g:456:8: public implicit_anonymous_function_parameter_list : implicit_anonymous_function_parameter ( ',' implicit_anonymous_function_parameter )* ;
	[GrammarRule("implicit_anonymous_function_parameter_list")]
	public csParser.implicit_anonymous_function_parameter_list_return implicit_anonymous_function_parameter_list()
	{
		Enter_implicit_anonymous_function_parameter_list();
		EnterRule("implicit_anonymous_function_parameter_list", 113);
		TraceIn("implicit_anonymous_function_parameter_list", 113);
		csParser.implicit_anonymous_function_parameter_list_return retval = new csParser.implicit_anonymous_function_parameter_list_return();
		retval.Start = (IToken)input.LT(1);
		int implicit_anonymous_function_parameter_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal426=null;
		csParser.implicit_anonymous_function_parameter_return implicit_anonymous_function_parameter425 = default(csParser.implicit_anonymous_function_parameter_return);
		csParser.implicit_anonymous_function_parameter_return implicit_anonymous_function_parameter427 = default(csParser.implicit_anonymous_function_parameter_return);

		object char_literal426_tree=null;

		try { DebugEnterRule(GrammarFileName, "implicit_anonymous_function_parameter_list");
		DebugLocation(456, 88);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 113)) { return retval; }
			// cs.g:456:50: ( implicit_anonymous_function_parameter ( ',' implicit_anonymous_function_parameter )* )
			DebugEnterAlt(1);
			// cs.g:457:2: implicit_anonymous_function_parameter ( ',' implicit_anonymous_function_parameter )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(457, 2);
			PushFollow(Follow._implicit_anonymous_function_parameter_in_implicit_anonymous_function_parameter_list3475);
			implicit_anonymous_function_parameter425=implicit_anonymous_function_parameter();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, implicit_anonymous_function_parameter425.Tree);
			DebugLocation(457, 42);
			// cs.g:457:42: ( ',' implicit_anonymous_function_parameter )*
			try { DebugEnterSubRule(121);
			while (true)
			{
				int alt121=2;
				try { DebugEnterDecision(121, decisionCanBacktrack[121]);
				int LA121_0 = input.LA(1);

				if ((LA121_0==91))
				{
					alt121=1;
				}


				} finally { DebugExitDecision(121); }
				switch ( alt121 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:457:43: ',' implicit_anonymous_function_parameter
					{
					DebugLocation(457, 43);
					char_literal426=(IToken)Match(input,91,Follow._91_in_implicit_anonymous_function_parameter_list3480); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal426_tree = (object)adaptor.Create(char_literal426);
					adaptor.AddChild(root_0, char_literal426_tree);
					}
					DebugLocation(457, 49);
					PushFollow(Follow._implicit_anonymous_function_parameter_in_implicit_anonymous_function_parameter_list3484);
					implicit_anonymous_function_parameter427=implicit_anonymous_function_parameter();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, implicit_anonymous_function_parameter427.Tree);

					}
					break;

				default:
					goto loop121;
				}
			}

			loop121:
				;

			} finally { DebugExitSubRule(121); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("implicit_anonymous_function_parameter_list", 113);
			LeaveRule("implicit_anonymous_function_parameter_list", 113);
			Leave_implicit_anonymous_function_parameter_list();
			if (state.backtracking > 0) { Memoize(input, 113, implicit_anonymous_function_parameter_list_StartIndex); }
		}
		DebugLocation(457, 88);
		} finally { DebugExitRule(GrammarFileName, "implicit_anonymous_function_parameter_list"); }
		return retval;

	}
	// $ANTLR end "implicit_anonymous_function_parameter_list"

	public class implicit_anonymous_function_parameter_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_implicit_anonymous_function_parameter();
	partial void Leave_implicit_anonymous_function_parameter();

	// $ANTLR start "implicit_anonymous_function_parameter"
	// cs.g:458:8: public implicit_anonymous_function_parameter : identifier ;
	[GrammarRule("implicit_anonymous_function_parameter")]
	public csParser.implicit_anonymous_function_parameter_return implicit_anonymous_function_parameter()
	{
		Enter_implicit_anonymous_function_parameter();
		EnterRule("implicit_anonymous_function_parameter", 114);
		TraceIn("implicit_anonymous_function_parameter", 114);
		csParser.implicit_anonymous_function_parameter_return retval = new csParser.implicit_anonymous_function_parameter_return();
		retval.Start = (IToken)input.LT(1);
		int implicit_anonymous_function_parameter_StartIndex = input.Index;
		object root_0 = null;

		csParser.identifier_return identifier428 = default(csParser.identifier_return);


		try { DebugEnterRule(GrammarFileName, "implicit_anonymous_function_parameter");
		DebugLocation(458, 11);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 114)) { return retval; }
			// cs.g:458:45: ( identifier )
			DebugEnterAlt(1);
			// cs.g:459:2: identifier
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(459, 2);
			PushFollow(Follow._identifier_in_implicit_anonymous_function_parameter3496);
			identifier428=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier428.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("implicit_anonymous_function_parameter", 114);
			LeaveRule("implicit_anonymous_function_parameter", 114);
			Leave_implicit_anonymous_function_parameter();
			if (state.backtracking > 0) { Memoize(input, 114, implicit_anonymous_function_parameter_StartIndex); }
		}
		DebugLocation(459, 11);
		} finally { DebugExitRule(GrammarFileName, "implicit_anonymous_function_parameter"); }
		return retval;

	}
	// $ANTLR end "implicit_anonymous_function_parameter"

	public class anonymous_function_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_anonymous_function_body();
	partial void Leave_anonymous_function_body();

	// $ANTLR start "anonymous_function_body"
	// cs.g:460:8: public anonymous_function_body : ( expression | block );
	[GrammarRule("anonymous_function_body")]
	public csParser.anonymous_function_body_return anonymous_function_body()
	{
		Enter_anonymous_function_body();
		EnterRule("anonymous_function_body", 115);
		TraceIn("anonymous_function_body", 115);
		csParser.anonymous_function_body_return retval = new csParser.anonymous_function_body_return();
		retval.Start = (IToken)input.LT(1);
		int anonymous_function_body_StartIndex = input.Index;
		object root_0 = null;

		csParser.expression_return expression429 = default(csParser.expression_return);
		csParser.block_return block430 = default(csParser.block_return);


		try { DebugEnterRule(GrammarFileName, "anonymous_function_body");
		DebugLocation(460, 9);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 115)) { return retval; }
			// cs.g:460:31: ( expression | block )
			int alt122=2;
			try { DebugEnterDecision(122, decisionCanBacktrack[122]);
			int LA122_0 = input.LA(1);

			if (((LA122_0>=IDENTIFIER && LA122_0<=NULL)||LA122_0==MINUS||(LA122_0>=ELIF && LA122_0<=UNDEF)||LA122_0==65||LA122_0==68||(LA122_0>=83 && LA122_0<=84)||(LA122_0>=86 && LA122_0<=87)||LA122_0==90||(LA122_0>=95 && LA122_0<=100)||LA122_0==102||(LA122_0>=104 && LA122_0<=106)||LA122_0==117||(LA122_0>=132 && LA122_0<=133)||(LA122_0>=135 && LA122_0<=148)||(LA122_0>=150 && LA122_0<=152)||LA122_0==154||(LA122_0>=156 && LA122_0<=168)||LA122_0==170||(LA122_0>=177 && LA122_0<=178)||(LA122_0>=195 && LA122_0<=202)))
			{
				alt122=1;
			}
			else if ((LA122_0==SEMI||LA122_0==62))
			{
				alt122=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 122, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(122); }
			switch (alt122)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:461:2: expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(461, 2);
				PushFollow(Follow._expression_in_anonymous_function_body3505);
				expression429=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression429.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:462:4: block
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(462, 4);
				PushFollow(Follow._block_in_anonymous_function_body3510);
				block430=block();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block430.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("anonymous_function_body", 115);
			LeaveRule("anonymous_function_body", 115);
			Leave_anonymous_function_body();
			if (state.backtracking > 0) { Memoize(input, 115, anonymous_function_body_StartIndex); }
		}
		DebugLocation(462, 9);
		} finally { DebugExitRule(GrammarFileName, "anonymous_function_body"); }
		return retval;

	}
	// $ANTLR end "anonymous_function_body"

	public class query_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_query_expression();
	partial void Leave_query_expression();

	// $ANTLR start "query_expression"
	// cs.g:467:8: public query_expression : from_clause query_body ;
	[GrammarRule("query_expression")]
	public csParser.query_expression_return query_expression()
	{
		Enter_query_expression();
		EnterRule("query_expression", 116);
		TraceIn("query_expression", 116);
		csParser.query_expression_return retval = new csParser.query_expression_return();
		retval.Start = (IToken)input.LT(1);
		int query_expression_StartIndex = input.Index;
		object root_0 = null;

		csParser.from_clause_return from_clause431 = default(csParser.from_clause_return);
		csParser.query_body_return query_body432 = default(csParser.query_body_return);


		try { DebugEnterRule(GrammarFileName, "query_expression");
		DebugLocation(467, 26);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 116)) { return retval; }
			// cs.g:467:24: ( from_clause query_body )
			DebugEnterAlt(1);
			// cs.g:468:2: from_clause query_body
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(468, 2);
			PushFollow(Follow._from_clause_in_query_expression3524);
			from_clause431=from_clause();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, from_clause431.Tree);
			DebugLocation(468, 16);
			PushFollow(Follow._query_body_in_query_expression3528);
			query_body432=query_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_body432.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("query_expression", 116);
			LeaveRule("query_expression", 116);
			Leave_query_expression();
			if (state.backtracking > 0) { Memoize(input, 116, query_expression_StartIndex); }
		}
		DebugLocation(468, 26);
		} finally { DebugExitRule(GrammarFileName, "query_expression"); }
		return retval;

	}
	// $ANTLR end "query_expression"

	public class query_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_query_body();
	partial void Leave_query_body();

	// $ANTLR start "query_body"
	// cs.g:469:8: public query_body : ( query_body_clauses )? select_or_group_clause ( ( 'into' )=> query_continuation )? ;
	[GrammarRule("query_body")]
	public csParser.query_body_return query_body()
	{
		Enter_query_body();
		EnterRule("query_body", 117);
		TraceIn("query_body", 117);
		csParser.query_body_return retval = new csParser.query_body_return();
		retval.Start = (IToken)input.LT(1);
		int query_body_StartIndex = input.Index;
		object root_0 = null;

		csParser.query_body_clauses_return query_body_clauses433 = default(csParser.query_body_clauses_return);
		csParser.select_or_group_clause_return select_or_group_clause434 = default(csParser.select_or_group_clause_return);
		csParser.query_continuation_return query_continuation435 = default(csParser.query_continuation_return);


		try { DebugEnterRule(GrammarFileName, "query_body");
		DebugLocation(469, 82);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 117)) { return retval; }
			// cs.g:469:18: ( ( query_body_clauses )? select_or_group_clause ( ( 'into' )=> query_continuation )? )
			DebugEnterAlt(1);
			// cs.g:471:2: ( query_body_clauses )? select_or_group_clause ( ( 'into' )=> query_continuation )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(471, 2);
			// cs.g:471:2: ( query_body_clauses )?
			int alt123=2;
			try { DebugEnterSubRule(123);
			try { DebugEnterDecision(123, decisionCanBacktrack[123]);
			int LA123_0 = input.LA(1);

			if ((LA123_0==133||LA123_0==135||(LA123_0>=138 && LA123_0<=139)||LA123_0==145))
			{
				alt123=1;
			}
			} finally { DebugExitDecision(123); }
			switch (alt123)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:471:2: query_body_clauses
				{
				DebugLocation(471, 2);
				PushFollow(Follow._query_body_clauses_in_query_body3540);
				query_body_clauses433=query_body_clauses();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_body_clauses433.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(123); }

			DebugLocation(471, 24);
			PushFollow(Follow._select_or_group_clause_in_query_body3545);
			select_or_group_clause434=select_or_group_clause();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, select_or_group_clause434.Tree);
			DebugLocation(471, 49);
			// cs.g:471:49: ( ( 'into' )=> query_continuation )?
			int alt124=2;
			try { DebugEnterSubRule(124);
			try { DebugEnterDecision(124, decisionCanBacktrack[124]);
			int LA124_0 = input.LA(1);

			if ((LA124_0==132))
			{
				int LA124_1 = input.LA(2);

				if ((EvaluatePredicate(synpred23_cs_fragment)))
				{
					alt124=1;
				}
			}
			} finally { DebugExitDecision(124); }
			switch (alt124)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:471:50: ( 'into' )=> query_continuation
				{
				DebugLocation(471, 62);
				PushFollow(Follow._query_continuation_in_query_body3556);
				query_continuation435=query_continuation();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_continuation435.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(124); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("query_body", 117);
			LeaveRule("query_body", 117);
			Leave_query_body();
			if (state.backtracking > 0) { Memoize(input, 117, query_body_StartIndex); }
		}
		DebugLocation(471, 82);
		} finally { DebugExitRule(GrammarFileName, "query_body"); }
		return retval;

	}
	// $ANTLR end "query_body"

	public class query_continuation_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_query_continuation();
	partial void Leave_query_continuation();

	// $ANTLR start "query_continuation"
	// cs.g:472:8: public query_continuation : 'into' identifier query_body ;
	[GrammarRule("query_continuation")]
	public csParser.query_continuation_return query_continuation()
	{
		Enter_query_continuation();
		EnterRule("query_continuation", 118);
		TraceIn("query_continuation", 118);
		csParser.query_continuation_return retval = new csParser.query_continuation_return();
		retval.Start = (IToken)input.LT(1);
		int query_continuation_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal436=null;
		csParser.identifier_return identifier437 = default(csParser.identifier_return);
		csParser.query_body_return query_body438 = default(csParser.query_body_return);

		object string_literal436_tree=null;

		try { DebugEnterRule(GrammarFileName, "query_continuation");
		DebugLocation(472, 33);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 118)) { return retval; }
			// cs.g:472:26: ( 'into' identifier query_body )
			DebugEnterAlt(1);
			// cs.g:473:2: 'into' identifier query_body
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(473, 2);
			string_literal436=(IToken)Match(input,132,Follow._132_in_query_continuation3568); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal436_tree = (object)adaptor.Create(string_literal436);
			adaptor.AddChild(root_0, string_literal436_tree);
			}
			DebugLocation(473, 11);
			PushFollow(Follow._identifier_in_query_continuation3572);
			identifier437=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier437.Tree);
			DebugLocation(473, 24);
			PushFollow(Follow._query_body_in_query_continuation3576);
			query_body438=query_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_body438.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("query_continuation", 118);
			LeaveRule("query_continuation", 118);
			Leave_query_continuation();
			if (state.backtracking > 0) { Memoize(input, 118, query_continuation_StartIndex); }
		}
		DebugLocation(473, 33);
		} finally { DebugExitRule(GrammarFileName, "query_continuation"); }
		return retval;

	}
	// $ANTLR end "query_continuation"

	public class query_body_clauses_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_query_body_clauses();
	partial void Leave_query_body_clauses();

	// $ANTLR start "query_body_clauses"
	// cs.g:474:8: public query_body_clauses : ( query_body_clause )+ ;
	[GrammarRule("query_body_clauses")]
	public csParser.query_body_clauses_return query_body_clauses()
	{
		Enter_query_body_clauses();
		EnterRule("query_body_clauses", 119);
		TraceIn("query_body_clauses", 119);
		csParser.query_body_clauses_return retval = new csParser.query_body_clauses_return();
		retval.Start = (IToken)input.LT(1);
		int query_body_clauses_StartIndex = input.Index;
		object root_0 = null;

		csParser.query_body_clause_return query_body_clause439 = default(csParser.query_body_clause_return);


		try { DebugEnterRule(GrammarFileName, "query_body_clauses");
		DebugLocation(474, 20);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 119)) { return retval; }
			// cs.g:474:26: ( ( query_body_clause )+ )
			DebugEnterAlt(1);
			// cs.g:475:2: ( query_body_clause )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(475, 2);
			// cs.g:475:2: ( query_body_clause )+
			int cnt125=0;
			try { DebugEnterSubRule(125);
			while (true)
			{
				int alt125=2;
				try { DebugEnterDecision(125, decisionCanBacktrack[125]);
				int LA125_0 = input.LA(1);

				if ((LA125_0==133||LA125_0==135||(LA125_0>=138 && LA125_0<=139)||LA125_0==145))
				{
					alt125=1;
				}


				} finally { DebugExitDecision(125); }
				switch (alt125)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:475:2: query_body_clause
					{
					DebugLocation(475, 2);
					PushFollow(Follow._query_body_clause_in_query_body_clauses3585);
					query_body_clause439=query_body_clause();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_body_clause439.Tree);

					}
					break;

				default:
					if (cnt125 >= 1)
						goto loop125;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee125 = new EarlyExitException( 125, input );
					DebugRecognitionException(eee125);
					throw eee125;
				}
				cnt125++;
			}
			loop125:
				;

			} finally { DebugExitSubRule(125); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("query_body_clauses", 119);
			LeaveRule("query_body_clauses", 119);
			Leave_query_body_clauses();
			if (state.backtracking > 0) { Memoize(input, 119, query_body_clauses_StartIndex); }
		}
		DebugLocation(475, 20);
		} finally { DebugExitRule(GrammarFileName, "query_body_clauses"); }
		return retval;

	}
	// $ANTLR end "query_body_clauses"

	public class query_body_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_query_body_clause();
	partial void Leave_query_body_clause();

	// $ANTLR start "query_body_clause"
	// cs.g:476:8: public query_body_clause : ( from_clause | let_clause | where_clause | join_clause | orderby_clause );
	[GrammarRule("query_body_clause")]
	public csParser.query_body_clause_return query_body_clause()
	{
		Enter_query_body_clause();
		EnterRule("query_body_clause", 120);
		TraceIn("query_body_clause", 120);
		csParser.query_body_clause_return retval = new csParser.query_body_clause_return();
		retval.Start = (IToken)input.LT(1);
		int query_body_clause_StartIndex = input.Index;
		object root_0 = null;

		csParser.from_clause_return from_clause440 = default(csParser.from_clause_return);
		csParser.let_clause_return let_clause441 = default(csParser.let_clause_return);
		csParser.where_clause_return where_clause442 = default(csParser.where_clause_return);
		csParser.join_clause_return join_clause443 = default(csParser.join_clause_return);
		csParser.orderby_clause_return orderby_clause444 = default(csParser.orderby_clause_return);


		try { DebugEnterRule(GrammarFileName, "query_body_clause");
		DebugLocation(476, 17);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 120)) { return retval; }
			// cs.g:476:25: ( from_clause | let_clause | where_clause | join_clause | orderby_clause )
			int alt126=5;
			try { DebugEnterDecision(126, decisionCanBacktrack[126]);
			switch (input.LA(1))
			{
			case 133:
				{
				alt126=1;
				}
				break;
			case 138:
				{
				alt126=2;
				}
				break;
			case 145:
				{
				alt126=3;
				}
				break;
			case 135:
				{
				alt126=4;
				}
				break;
			case 139:
				{
				alt126=5;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 126, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(126); }
			switch (alt126)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:477:2: from_clause
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(477, 2);
				PushFollow(Follow._from_clause_in_query_body_clause3596);
				from_clause440=from_clause();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, from_clause440.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:478:4: let_clause
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(478, 4);
				PushFollow(Follow._let_clause_in_query_body_clause3601);
				let_clause441=let_clause();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, let_clause441.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:479:4: where_clause
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(479, 4);
				PushFollow(Follow._where_clause_in_query_body_clause3606);
				where_clause442=where_clause();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, where_clause442.Tree);

				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:480:4: join_clause
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(480, 4);
				PushFollow(Follow._join_clause_in_query_body_clause3611);
				join_clause443=join_clause();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, join_clause443.Tree);

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:481:4: orderby_clause
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(481, 4);
				PushFollow(Follow._orderby_clause_in_query_body_clause3616);
				orderby_clause444=orderby_clause();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, orderby_clause444.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("query_body_clause", 120);
			LeaveRule("query_body_clause", 120);
			Leave_query_body_clause();
			if (state.backtracking > 0) { Memoize(input, 120, query_body_clause_StartIndex); }
		}
		DebugLocation(481, 17);
		} finally { DebugExitRule(GrammarFileName, "query_body_clause"); }
		return retval;

	}
	// $ANTLR end "query_body_clause"

	public class from_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_from_clause();
	partial void Leave_from_clause();

	// $ANTLR start "from_clause"
	// cs.g:482:8: public from_clause : 'from' ( type )? identifier 'in' expression ;
	[GrammarRule("from_clause")]
	public csParser.from_clause_return from_clause()
	{
		Enter_from_clause();
		EnterRule("from_clause", 121);
		TraceIn("from_clause", 121);
		csParser.from_clause_return retval = new csParser.from_clause_return();
		retval.Start = (IToken)input.LT(1);
		int from_clause_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal445=null;
		IToken string_literal448=null;
		csParser.type_return type446 = default(csParser.type_return);
		csParser.identifier_return identifier447 = default(csParser.identifier_return);
		csParser.expression_return expression449 = default(csParser.expression_return);

		object string_literal445_tree=null;
		object string_literal448_tree=null;

		try { DebugEnterRule(GrammarFileName, "from_clause");
		DebugLocation(482, 49);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 121)) { return retval; }
			// cs.g:482:19: ( 'from' ( type )? identifier 'in' expression )
			DebugEnterAlt(1);
			// cs.g:483:2: 'from' ( type )? identifier 'in' expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(483, 2);
			string_literal445=(IToken)Match(input,133,Follow._133_in_from_clause3625); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal445_tree = (object)adaptor.Create(string_literal445);
			adaptor.AddChild(root_0, string_literal445_tree);
			}
			DebugLocation(483, 11);
			// cs.g:483:11: ( type )?
			int alt127=2;
			try { DebugEnterSubRule(127);
			try { DebugEnterDecision(127, decisionCanBacktrack[127]);
			switch (input.LA(1))
			{
			case 82:
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 196:
			case 197:
			case 198:
			case 199:
			case 200:
			case 201:
				{
				alt127=1;
				}
				break;
			case IDENTIFIER:
				{
				int LA127_2 = input.LA(2);

				if ((LA127_2==IDENTIFIER||LA127_2==DOT||(LA127_2>=ELIF && LA127_2<=UNDEF)||LA127_2==65||LA127_2==85||LA127_2==88||(LA127_2>=101 && LA127_2<=103)||(LA127_2>=132 && LA127_2<=133)||(LA127_2>=135 && LA127_2<=148)||(LA127_2>=150 && LA127_2<=152)||LA127_2==154||(LA127_2>=156 && LA127_2<=159)||LA127_2==170||(LA127_2>=177 && LA127_2<=178)||LA127_2==195||LA127_2==202))
				{
					alt127=1;
				}
				}
				break;
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 132:
			case 133:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 170:
			case 177:
			case 178:
			case 195:
			case 202:
				{
				int LA127_3 = input.LA(2);

				if ((LA127_3==IDENTIFIER||LA127_3==DOT||(LA127_3>=ELIF && LA127_3<=UNDEF)||LA127_3==65||LA127_3==85||LA127_3==88||(LA127_3>=101 && LA127_3<=103)||(LA127_3>=132 && LA127_3<=133)||(LA127_3>=135 && LA127_3<=148)||(LA127_3>=150 && LA127_3<=152)||LA127_3==154||(LA127_3>=156 && LA127_3<=159)||LA127_3==170||(LA127_3>=177 && LA127_3<=178)||LA127_3==195||LA127_3==202))
				{
					alt127=1;
				}
				}
				break;
			}

			} finally { DebugExitDecision(127); }
			switch (alt127)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:483:11: type
				{
				DebugLocation(483, 11);
				PushFollow(Follow._type_in_from_clause3629);
				type446=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type446.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(127); }

			DebugLocation(483, 19);
			PushFollow(Follow._identifier_in_from_clause3634);
			identifier447=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier447.Tree);
			DebugLocation(483, 32);
			string_literal448=(IToken)Match(input,134,Follow._134_in_from_clause3638); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal448_tree = (object)adaptor.Create(string_literal448);
			adaptor.AddChild(root_0, string_literal448_tree);
			}
			DebugLocation(483, 39);
			PushFollow(Follow._expression_in_from_clause3642);
			expression449=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression449.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("from_clause", 121);
			LeaveRule("from_clause", 121);
			Leave_from_clause();
			if (state.backtracking > 0) { Memoize(input, 121, from_clause_StartIndex); }
		}
		DebugLocation(483, 49);
		} finally { DebugExitRule(GrammarFileName, "from_clause"); }
		return retval;

	}
	// $ANTLR end "from_clause"

	public class join_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_join_clause();
	partial void Leave_join_clause();

	// $ANTLR start "join_clause"
	// cs.g:484:8: public join_clause : 'join' ( type )? identifier 'in' expression 'on' expression 'equals' expression ( 'into' identifier )? ;
	[GrammarRule("join_clause")]
	public csParser.join_clause_return join_clause()
	{
		Enter_join_clause();
		EnterRule("join_clause", 122);
		TraceIn("join_clause", 122);
		csParser.join_clause_return retval = new csParser.join_clause_return();
		retval.Start = (IToken)input.LT(1);
		int join_clause_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal450=null;
		IToken string_literal453=null;
		IToken string_literal455=null;
		IToken string_literal457=null;
		IToken string_literal459=null;
		csParser.type_return type451 = default(csParser.type_return);
		csParser.identifier_return identifier452 = default(csParser.identifier_return);
		csParser.expression_return expression454 = default(csParser.expression_return);
		csParser.expression_return expression456 = default(csParser.expression_return);
		csParser.expression_return expression458 = default(csParser.expression_return);
		csParser.identifier_return identifier460 = default(csParser.identifier_return);

		object string_literal450_tree=null;
		object string_literal453_tree=null;
		object string_literal455_tree=null;
		object string_literal457_tree=null;
		object string_literal459_tree=null;

		try { DebugEnterRule(GrammarFileName, "join_clause");
		DebugLocation(484, 114);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 122)) { return retval; }
			// cs.g:484:19: ( 'join' ( type )? identifier 'in' expression 'on' expression 'equals' expression ( 'into' identifier )? )
			DebugEnterAlt(1);
			// cs.g:485:2: 'join' ( type )? identifier 'in' expression 'on' expression 'equals' expression ( 'into' identifier )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(485, 2);
			string_literal450=(IToken)Match(input,135,Follow._135_in_join_clause3652); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal450_tree = (object)adaptor.Create(string_literal450);
			adaptor.AddChild(root_0, string_literal450_tree);
			}
			DebugLocation(485, 11);
			// cs.g:485:11: ( type )?
			int alt128=2;
			try { DebugEnterSubRule(128);
			try { DebugEnterDecision(128, decisionCanBacktrack[128]);
			switch (input.LA(1))
			{
			case 82:
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 196:
			case 197:
			case 198:
			case 199:
			case 200:
			case 201:
				{
				alt128=1;
				}
				break;
			case IDENTIFIER:
				{
				int LA128_2 = input.LA(2);

				if ((LA128_2==IDENTIFIER||LA128_2==DOT||(LA128_2>=ELIF && LA128_2<=UNDEF)||LA128_2==65||LA128_2==85||LA128_2==88||(LA128_2>=101 && LA128_2<=103)||(LA128_2>=132 && LA128_2<=133)||(LA128_2>=135 && LA128_2<=148)||(LA128_2>=150 && LA128_2<=152)||LA128_2==154||(LA128_2>=156 && LA128_2<=159)||LA128_2==170||(LA128_2>=177 && LA128_2<=178)||LA128_2==195||LA128_2==202))
				{
					alt128=1;
				}
				}
				break;
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 132:
			case 133:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 170:
			case 177:
			case 178:
			case 195:
			case 202:
				{
				int LA128_3 = input.LA(2);

				if ((LA128_3==IDENTIFIER||LA128_3==DOT||(LA128_3>=ELIF && LA128_3<=UNDEF)||LA128_3==65||LA128_3==85||LA128_3==88||(LA128_3>=101 && LA128_3<=103)||(LA128_3>=132 && LA128_3<=133)||(LA128_3>=135 && LA128_3<=148)||(LA128_3>=150 && LA128_3<=152)||LA128_3==154||(LA128_3>=156 && LA128_3<=159)||LA128_3==170||(LA128_3>=177 && LA128_3<=178)||LA128_3==195||LA128_3==202))
				{
					alt128=1;
				}
				}
				break;
			}

			} finally { DebugExitDecision(128); }
			switch (alt128)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:485:11: type
				{
				DebugLocation(485, 11);
				PushFollow(Follow._type_in_join_clause3656);
				type451=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type451.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(128); }

			DebugLocation(485, 19);
			PushFollow(Follow._identifier_in_join_clause3661);
			identifier452=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier452.Tree);
			DebugLocation(485, 32);
			string_literal453=(IToken)Match(input,134,Follow._134_in_join_clause3665); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal453_tree = (object)adaptor.Create(string_literal453);
			adaptor.AddChild(root_0, string_literal453_tree);
			}
			DebugLocation(485, 39);
			PushFollow(Follow._expression_in_join_clause3669);
			expression454=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression454.Tree);
			DebugLocation(485, 52);
			string_literal455=(IToken)Match(input,136,Follow._136_in_join_clause3673); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal455_tree = (object)adaptor.Create(string_literal455);
			adaptor.AddChild(root_0, string_literal455_tree);
			}
			DebugLocation(485, 59);
			PushFollow(Follow._expression_in_join_clause3677);
			expression456=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression456.Tree);
			DebugLocation(485, 72);
			string_literal457=(IToken)Match(input,137,Follow._137_in_join_clause3681); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal457_tree = (object)adaptor.Create(string_literal457);
			adaptor.AddChild(root_0, string_literal457_tree);
			}
			DebugLocation(485, 83);
			PushFollow(Follow._expression_in_join_clause3685);
			expression458=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression458.Tree);
			DebugLocation(485, 94);
			// cs.g:485:94: ( 'into' identifier )?
			int alt129=2;
			try { DebugEnterSubRule(129);
			try { DebugEnterDecision(129, decisionCanBacktrack[129]);
			int LA129_0 = input.LA(1);

			if ((LA129_0==132))
			{
				alt129=1;
			}
			} finally { DebugExitDecision(129); }
			switch (alt129)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:485:95: 'into' identifier
				{
				DebugLocation(485, 95);
				string_literal459=(IToken)Match(input,132,Follow._132_in_join_clause3688); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal459_tree = (object)adaptor.Create(string_literal459);
				adaptor.AddChild(root_0, string_literal459_tree);
				}
				DebugLocation(485, 102);
				PushFollow(Follow._identifier_in_join_clause3690);
				identifier460=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier460.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(129); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("join_clause", 122);
			LeaveRule("join_clause", 122);
			Leave_join_clause();
			if (state.backtracking > 0) { Memoize(input, 122, join_clause_StartIndex); }
		}
		DebugLocation(485, 114);
		} finally { DebugExitRule(GrammarFileName, "join_clause"); }
		return retval;

	}
	// $ANTLR end "join_clause"

	public class let_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_let_clause();
	partial void Leave_let_clause();

	// $ANTLR start "let_clause"
	// cs.g:486:8: public let_clause : 'let' identifier '=' expression ;
	[GrammarRule("let_clause")]
	public csParser.let_clause_return let_clause()
	{
		Enter_let_clause();
		EnterRule("let_clause", 123);
		TraceIn("let_clause", 123);
		csParser.let_clause_return retval = new csParser.let_clause_return();
		retval.Start = (IToken)input.LT(1);
		int let_clause_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal461=null;
		IToken char_literal463=null;
		csParser.identifier_return identifier462 = default(csParser.identifier_return);
		csParser.expression_return expression464 = default(csParser.expression_return);

		object string_literal461_tree=null;
		object char_literal463_tree=null;

		try { DebugEnterRule(GrammarFileName, "let_clause");
		DebugLocation(486, 38);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 123)) { return retval; }
			// cs.g:486:18: ( 'let' identifier '=' expression )
			DebugEnterAlt(1);
			// cs.g:487:2: 'let' identifier '=' expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(487, 2);
			string_literal461=(IToken)Match(input,138,Follow._138_in_let_clause3702); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal461_tree = (object)adaptor.Create(string_literal461);
			adaptor.AddChild(root_0, string_literal461_tree);
			}
			DebugLocation(487, 10);
			PushFollow(Follow._identifier_in_let_clause3706);
			identifier462=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier462.Tree);
			DebugLocation(487, 23);
			char_literal463=(IToken)Match(input,66,Follow._66_in_let_clause3710); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal463_tree = (object)adaptor.Create(char_literal463);
			adaptor.AddChild(root_0, char_literal463_tree);
			}
			DebugLocation(487, 29);
			PushFollow(Follow._expression_in_let_clause3714);
			expression464=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression464.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("let_clause", 123);
			LeaveRule("let_clause", 123);
			Leave_let_clause();
			if (state.backtracking > 0) { Memoize(input, 123, let_clause_StartIndex); }
		}
		DebugLocation(487, 38);
		} finally { DebugExitRule(GrammarFileName, "let_clause"); }
		return retval;

	}
	// $ANTLR end "let_clause"

	public class orderby_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_orderby_clause();
	partial void Leave_orderby_clause();

	// $ANTLR start "orderby_clause"
	// cs.g:488:8: public orderby_clause : 'orderby' ordering_list ;
	[GrammarRule("orderby_clause")]
	public csParser.orderby_clause_return orderby_clause()
	{
		Enter_orderby_clause();
		EnterRule("orderby_clause", 124);
		TraceIn("orderby_clause", 124);
		csParser.orderby_clause_return retval = new csParser.orderby_clause_return();
		retval.Start = (IToken)input.LT(1);
		int orderby_clause_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal465=null;
		csParser.ordering_list_return ordering_list466 = default(csParser.ordering_list_return);

		object string_literal465_tree=null;

		try { DebugEnterRule(GrammarFileName, "orderby_clause");
		DebugLocation(488, 27);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 124)) { return retval; }
			// cs.g:488:22: ( 'orderby' ordering_list )
			DebugEnterAlt(1);
			// cs.g:489:2: 'orderby' ordering_list
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(489, 2);
			string_literal465=(IToken)Match(input,139,Follow._139_in_orderby_clause3723); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal465_tree = (object)adaptor.Create(string_literal465);
			adaptor.AddChild(root_0, string_literal465_tree);
			}
			DebugLocation(489, 14);
			PushFollow(Follow._ordering_list_in_orderby_clause3727);
			ordering_list466=ordering_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ordering_list466.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("orderby_clause", 124);
			LeaveRule("orderby_clause", 124);
			Leave_orderby_clause();
			if (state.backtracking > 0) { Memoize(input, 124, orderby_clause_StartIndex); }
		}
		DebugLocation(489, 27);
		} finally { DebugExitRule(GrammarFileName, "orderby_clause"); }
		return retval;

	}
	// $ANTLR end "orderby_clause"

	public class ordering_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_ordering_list();
	partial void Leave_ordering_list();

	// $ANTLR start "ordering_list"
	// cs.g:490:8: public ordering_list : ordering ( ',' ordering )* ;
	[GrammarRule("ordering_list")]
	public csParser.ordering_list_return ordering_list()
	{
		Enter_ordering_list();
		EnterRule("ordering_list", 125);
		TraceIn("ordering_list", 125);
		csParser.ordering_list_return retval = new csParser.ordering_list_return();
		retval.Start = (IToken)input.LT(1);
		int ordering_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal468=null;
		csParser.ordering_return ordering467 = default(csParser.ordering_return);
		csParser.ordering_return ordering469 = default(csParser.ordering_return);

		object char_literal468_tree=null;

		try { DebugEnterRule(GrammarFileName, "ordering_list");
		DebugLocation(490, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 125)) { return retval; }
			// cs.g:490:21: ( ordering ( ',' ordering )* )
			DebugEnterAlt(1);
			// cs.g:491:2: ordering ( ',' ordering )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(491, 2);
			PushFollow(Follow._ordering_in_ordering_list3737);
			ordering467=ordering();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ordering467.Tree);
			DebugLocation(491, 13);
			// cs.g:491:13: ( ',' ordering )*
			try { DebugEnterSubRule(130);
			while (true)
			{
				int alt130=2;
				try { DebugEnterDecision(130, decisionCanBacktrack[130]);
				int LA130_0 = input.LA(1);

				if ((LA130_0==91))
				{
					alt130=1;
				}


				} finally { DebugExitDecision(130); }
				switch ( alt130 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:491:14: ',' ordering
					{
					DebugLocation(491, 14);
					char_literal468=(IToken)Match(input,91,Follow._91_in_ordering_list3742); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal468_tree = (object)adaptor.Create(char_literal468);
					adaptor.AddChild(root_0, char_literal468_tree);
					}
					DebugLocation(491, 20);
					PushFollow(Follow._ordering_in_ordering_list3746);
					ordering469=ordering();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ordering469.Tree);

					}
					break;

				default:
					goto loop130;
				}
			}

			loop130:
				;

			} finally { DebugExitSubRule(130); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("ordering_list", 125);
			LeaveRule("ordering_list", 125);
			Leave_ordering_list();
			if (state.backtracking > 0) { Memoize(input, 125, ordering_list_StartIndex); }
		}
		DebugLocation(491, 30);
		} finally { DebugExitRule(GrammarFileName, "ordering_list"); }
		return retval;

	}
	// $ANTLR end "ordering_list"

	public class ordering_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_ordering();
	partial void Leave_ordering();

	// $ANTLR start "ordering"
	// cs.g:492:8: public ordering : expression ordering_direction ;
	[GrammarRule("ordering")]
	public csParser.ordering_return ordering()
	{
		Enter_ordering();
		EnterRule("ordering", 126);
		TraceIn("ordering", 126);
		csParser.ordering_return retval = new csParser.ordering_return();
		retval.Start = (IToken)input.LT(1);
		int ordering_StartIndex = input.Index;
		object root_0 = null;

		csParser.expression_return expression470 = default(csParser.expression_return);
		csParser.ordering_direction_return ordering_direction471 = default(csParser.ordering_direction_return);


		try { DebugEnterRule(GrammarFileName, "ordering");
		DebugLocation(492, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 126)) { return retval; }
			// cs.g:492:16: ( expression ordering_direction )
			DebugEnterAlt(1);
			// cs.g:493:2: expression ordering_direction
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(493, 2);
			PushFollow(Follow._expression_in_ordering3758);
			expression470=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression470.Tree);
			DebugLocation(493, 16);
			PushFollow(Follow._ordering_direction_in_ordering3763);
			ordering_direction471=ordering_direction();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ordering_direction471.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("ordering", 126);
			LeaveRule("ordering", 126);
			Leave_ordering();
			if (state.backtracking > 0) { Memoize(input, 126, ordering_StartIndex); }
		}
		DebugLocation(494, 1);
		} finally { DebugExitRule(GrammarFileName, "ordering"); }
		return retval;

	}
	// $ANTLR end "ordering"

	public class ordering_direction_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_ordering_direction();
	partial void Leave_ordering_direction();

	// $ANTLR start "ordering_direction"
	// cs.g:495:8: public ordering_direction : ( 'ascending' | 'descending' );
	[GrammarRule("ordering_direction")]
	public csParser.ordering_direction_return ordering_direction()
	{
		Enter_ordering_direction();
		EnterRule("ordering_direction", 127);
		TraceIn("ordering_direction", 127);
		csParser.ordering_direction_return retval = new csParser.ordering_direction_return();
		retval.Start = (IToken)input.LT(1);
		int ordering_direction_StartIndex = input.Index;
		object root_0 = null;

		IToken set472=null;

		object set472_tree=null;

		try { DebugEnterRule(GrammarFileName, "ordering_direction");
		DebugLocation(495, 16);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 127)) { return retval; }
			// cs.g:495:26: ( 'ascending' | 'descending' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(495, 26);
			set472=(IToken)input.LT(1);
			if ((input.LA(1)>=140 && input.LA(1)<=141))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set472));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("ordering_direction", 127);
			LeaveRule("ordering_direction", 127);
			Leave_ordering_direction();
			if (state.backtracking > 0) { Memoize(input, 127, ordering_direction_StartIndex); }
		}
		DebugLocation(497, 16);
		} finally { DebugExitRule(GrammarFileName, "ordering_direction"); }
		return retval;

	}
	// $ANTLR end "ordering_direction"

	public class select_or_group_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_select_or_group_clause();
	partial void Leave_select_or_group_clause();

	// $ANTLR start "select_or_group_clause"
	// cs.g:498:8: public select_or_group_clause : ( select_clause | group_clause );
	[GrammarRule("select_or_group_clause")]
	public csParser.select_or_group_clause_return select_or_group_clause()
	{
		Enter_select_or_group_clause();
		EnterRule("select_or_group_clause", 128);
		TraceIn("select_or_group_clause", 128);
		csParser.select_or_group_clause_return retval = new csParser.select_or_group_clause_return();
		retval.Start = (IToken)input.LT(1);
		int select_or_group_clause_StartIndex = input.Index;
		object root_0 = null;

		csParser.select_clause_return select_clause473 = default(csParser.select_clause_return);
		csParser.group_clause_return group_clause474 = default(csParser.group_clause_return);


		try { DebugEnterRule(GrammarFileName, "select_or_group_clause");
		DebugLocation(498, 16);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 128)) { return retval; }
			// cs.g:498:30: ( select_clause | group_clause )
			int alt131=2;
			try { DebugEnterDecision(131, decisionCanBacktrack[131]);
			int LA131_0 = input.LA(1);

			if ((LA131_0==142))
			{
				alt131=1;
			}
			else if ((LA131_0==143))
			{
				alt131=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 131, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(131); }
			switch (alt131)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:499:2: select_clause
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(499, 2);
				PushFollow(Follow._select_clause_in_select_or_group_clause3789);
				select_clause473=select_clause();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, select_clause473.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:500:4: group_clause
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(500, 4);
				PushFollow(Follow._group_clause_in_select_or_group_clause3794);
				group_clause474=group_clause();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, group_clause474.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("select_or_group_clause", 128);
			LeaveRule("select_or_group_clause", 128);
			Leave_select_or_group_clause();
			if (state.backtracking > 0) { Memoize(input, 128, select_or_group_clause_StartIndex); }
		}
		DebugLocation(500, 16);
		} finally { DebugExitRule(GrammarFileName, "select_or_group_clause"); }
		return retval;

	}
	// $ANTLR end "select_or_group_clause"

	public class select_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_select_clause();
	partial void Leave_select_clause();

	// $ANTLR start "select_clause"
	// cs.g:501:8: public select_clause : 'select' expression ;
	[GrammarRule("select_clause")]
	public csParser.select_clause_return select_clause()
	{
		Enter_select_clause();
		EnterRule("select_clause", 129);
		TraceIn("select_clause", 129);
		csParser.select_clause_return retval = new csParser.select_clause_return();
		retval.Start = (IToken)input.LT(1);
		int select_clause_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal475=null;
		csParser.expression_return expression476 = default(csParser.expression_return);

		object string_literal475_tree=null;

		try { DebugEnterRule(GrammarFileName, "select_clause");
		DebugLocation(501, 23);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 129)) { return retval; }
			// cs.g:501:21: ( 'select' expression )
			DebugEnterAlt(1);
			// cs.g:502:2: 'select' expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(502, 2);
			string_literal475=(IToken)Match(input,142,Follow._142_in_select_clause3804); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal475_tree = (object)adaptor.Create(string_literal475);
			adaptor.AddChild(root_0, string_literal475_tree);
			}
			DebugLocation(502, 13);
			PushFollow(Follow._expression_in_select_clause3808);
			expression476=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression476.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("select_clause", 129);
			LeaveRule("select_clause", 129);
			Leave_select_clause();
			if (state.backtracking > 0) { Memoize(input, 129, select_clause_StartIndex); }
		}
		DebugLocation(502, 23);
		} finally { DebugExitRule(GrammarFileName, "select_clause"); }
		return retval;

	}
	// $ANTLR end "select_clause"

	public class group_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_group_clause();
	partial void Leave_group_clause();

	// $ANTLR start "group_clause"
	// cs.g:503:8: public group_clause : 'group' expression 'by' expression ;
	[GrammarRule("group_clause")]
	public csParser.group_clause_return group_clause()
	{
		Enter_group_clause();
		EnterRule("group_clause", 130);
		TraceIn("group_clause", 130);
		csParser.group_clause_return retval = new csParser.group_clause_return();
		retval.Start = (IToken)input.LT(1);
		int group_clause_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal477=null;
		IToken string_literal479=null;
		csParser.expression_return expression478 = default(csParser.expression_return);
		csParser.expression_return expression480 = default(csParser.expression_return);

		object string_literal477_tree=null;
		object string_literal479_tree=null;

		try { DebugEnterRule(GrammarFileName, "group_clause");
		DebugLocation(503, 42);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 130)) { return retval; }
			// cs.g:503:20: ( 'group' expression 'by' expression )
			DebugEnterAlt(1);
			// cs.g:504:2: 'group' expression 'by' expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(504, 2);
			string_literal477=(IToken)Match(input,143,Follow._143_in_group_clause3818); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal477_tree = (object)adaptor.Create(string_literal477);
			adaptor.AddChild(root_0, string_literal477_tree);
			}
			DebugLocation(504, 12);
			PushFollow(Follow._expression_in_group_clause3822);
			expression478=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression478.Tree);
			DebugLocation(504, 25);
			string_literal479=(IToken)Match(input,144,Follow._144_in_group_clause3826); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal479_tree = (object)adaptor.Create(string_literal479);
			adaptor.AddChild(root_0, string_literal479_tree);
			}
			DebugLocation(504, 32);
			PushFollow(Follow._expression_in_group_clause3830);
			expression480=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression480.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("group_clause", 130);
			LeaveRule("group_clause", 130);
			Leave_group_clause();
			if (state.backtracking > 0) { Memoize(input, 130, group_clause_StartIndex); }
		}
		DebugLocation(504, 42);
		} finally { DebugExitRule(GrammarFileName, "group_clause"); }
		return retval;

	}
	// $ANTLR end "group_clause"

	public class where_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_where_clause();
	partial void Leave_where_clause();

	// $ANTLR start "where_clause"
	// cs.g:505:8: public where_clause : 'where' boolean_expression ;
	[GrammarRule("where_clause")]
	public csParser.where_clause_return where_clause()
	{
		Enter_where_clause();
		EnterRule("where_clause", 131);
		TraceIn("where_clause", 131);
		csParser.where_clause_return retval = new csParser.where_clause_return();
		retval.Start = (IToken)input.LT(1);
		int where_clause_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal481=null;
		csParser.boolean_expression_return boolean_expression482 = default(csParser.boolean_expression_return);

		object string_literal481_tree=null;

		try { DebugEnterRule(GrammarFileName, "where_clause");
		DebugLocation(505, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 131)) { return retval; }
			// cs.g:505:20: ( 'where' boolean_expression )
			DebugEnterAlt(1);
			// cs.g:506:2: 'where' boolean_expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(506, 2);
			string_literal481=(IToken)Match(input,145,Follow._145_in_where_clause3840); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal481_tree = (object)adaptor.Create(string_literal481);
			adaptor.AddChild(root_0, string_literal481_tree);
			}
			DebugLocation(506, 12);
			PushFollow(Follow._boolean_expression_in_where_clause3844);
			boolean_expression482=boolean_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, boolean_expression482.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("where_clause", 131);
			LeaveRule("where_clause", 131);
			Leave_where_clause();
			if (state.backtracking > 0) { Memoize(input, 131, where_clause_StartIndex); }
		}
		DebugLocation(506, 30);
		} finally { DebugExitRule(GrammarFileName, "where_clause"); }
		return retval;

	}
	// $ANTLR end "where_clause"

	public class boolean_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_boolean_expression();
	partial void Leave_boolean_expression();

	// $ANTLR start "boolean_expression"
	// cs.g:507:8: public boolean_expression : expression ;
	[GrammarRule("boolean_expression")]
	public csParser.boolean_expression_return boolean_expression()
	{
		Enter_boolean_expression();
		EnterRule("boolean_expression", 132);
		TraceIn("boolean_expression", 132);
		csParser.boolean_expression_return retval = new csParser.boolean_expression_return();
		retval.Start = (IToken)input.LT(1);
		int boolean_expression_StartIndex = input.Index;
		object root_0 = null;

		csParser.expression_return expression483 = default(csParser.expression_return);


		try { DebugEnterRule(GrammarFileName, "boolean_expression");
		DebugLocation(507, 11);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 132)) { return retval; }
			// cs.g:507:26: ( expression )
			DebugEnterAlt(1);
			// cs.g:508:2: expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(508, 2);
			PushFollow(Follow._expression_in_boolean_expression3854);
			expression483=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression483.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("boolean_expression", 132);
			LeaveRule("boolean_expression", 132);
			Leave_boolean_expression();
			if (state.backtracking > 0) { Memoize(input, 132, boolean_expression_StartIndex); }
		}
		DebugLocation(508, 11);
		} finally { DebugExitRule(GrammarFileName, "boolean_expression"); }
		return retval;

	}
	// $ANTLR end "boolean_expression"

	public class global_attributes_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_global_attributes();
	partial void Leave_global_attributes();

	// $ANTLR start "global_attributes"
	// cs.g:513:8: public global_attributes : ( global_attribute )+ ;
	[GrammarRule("global_attributes")]
	public csParser.global_attributes_return global_attributes()
	{
		Enter_global_attributes();
		EnterRule("global_attributes", 133);
		TraceIn("global_attributes", 133);
		csParser.global_attributes_return retval = new csParser.global_attributes_return();
		retval.Start = (IToken)input.LT(1);
		int global_attributes_StartIndex = input.Index;
		object root_0 = null;

		csParser.global_attribute_return global_attribute484 = default(csParser.global_attribute_return);


		try { DebugEnterRule(GrammarFileName, "global_attributes");
		DebugLocation(513, 19);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 133)) { return retval; }
			// cs.g:513:25: ( ( global_attribute )+ )
			DebugEnterAlt(1);
			// cs.g:514:2: ( global_attribute )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(514, 2);
			// cs.g:514:2: ( global_attribute )+
			int cnt132=0;
			try { DebugEnterSubRule(132);
			while (true)
			{
				int alt132=2;
				try { DebugEnterDecision(132, decisionCanBacktrack[132]);
				int LA132_0 = input.LA(1);

				if ((LA132_0==88))
				{
					int LA132_2 = input.LA(2);

					if (((LA132_2>=146 && LA132_2<=147)))
					{
						int LA132_3 = input.LA(3);

						if ((LA132_3==92))
						{
							alt132=1;
						}


					}


				}


				} finally { DebugExitDecision(132); }
				switch (alt132)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:514:2: global_attribute
					{
					DebugLocation(514, 2);
					PushFollow(Follow._global_attribute_in_global_attributes3868);
					global_attribute484=global_attribute();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, global_attribute484.Tree);

					}
					break;

				default:
					if (cnt132 >= 1)
						goto loop132;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee132 = new EarlyExitException( 132, input );
					DebugRecognitionException(eee132);
					throw eee132;
				}
				cnt132++;
			}
			loop132:
				;

			} finally { DebugExitSubRule(132); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("global_attributes", 133);
			LeaveRule("global_attributes", 133);
			Leave_global_attributes();
			if (state.backtracking > 0) { Memoize(input, 133, global_attributes_StartIndex); }
		}
		DebugLocation(514, 19);
		} finally { DebugExitRule(GrammarFileName, "global_attributes"); }
		return retval;

	}
	// $ANTLR end "global_attributes"

	public class global_attribute_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_global_attribute();
	partial void Leave_global_attribute();

	// $ANTLR start "global_attribute"
	// cs.g:515:8: public global_attribute : '[' global_attribute_target_specifier attribute_list ( ',' )? ']' ;
	[GrammarRule("global_attribute")]
	public csParser.global_attribute_return global_attribute()
	{
		Enter_global_attribute();
		EnterRule("global_attribute", 134);
		TraceIn("global_attribute", 134);
		csParser.global_attribute_return retval = new csParser.global_attribute_return();
		retval.Start = (IToken)input.LT(1);
		int global_attribute_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal485=null;
		IToken char_literal488=null;
		IToken char_literal489=null;
		csParser.global_attribute_target_specifier_return global_attribute_target_specifier486 = default(csParser.global_attribute_target_specifier_return);
		csParser.attribute_list_return attribute_list487 = default(csParser.attribute_list_return);

		object char_literal485_tree=null;
		object char_literal488_tree=null;
		object char_literal489_tree=null;

		try { DebugEnterRule(GrammarFileName, "global_attribute");
		DebugLocation(515, 71);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 134)) { return retval; }
			// cs.g:515:24: ( '[' global_attribute_target_specifier attribute_list ( ',' )? ']' )
			DebugEnterAlt(1);
			// cs.g:516:2: '[' global_attribute_target_specifier attribute_list ( ',' )? ']'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(516, 2);
			char_literal485=(IToken)Match(input,88,Follow._88_in_global_attribute3880); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal485_tree = (object)adaptor.Create(char_literal485);
			adaptor.AddChild(root_0, char_literal485_tree);
			}
			DebugLocation(516, 8);
			PushFollow(Follow._global_attribute_target_specifier_in_global_attribute3884);
			global_attribute_target_specifier486=global_attribute_target_specifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, global_attribute_target_specifier486.Tree);
			DebugLocation(516, 44);
			PushFollow(Follow._attribute_list_in_global_attribute3888);
			attribute_list487=attribute_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_list487.Tree);
			DebugLocation(516, 61);
			// cs.g:516:61: ( ',' )?
			int alt133=2;
			try { DebugEnterSubRule(133);
			try { DebugEnterDecision(133, decisionCanBacktrack[133]);
			int LA133_0 = input.LA(1);

			if ((LA133_0==91))
			{
				alt133=1;
			}
			} finally { DebugExitDecision(133); }
			switch (alt133)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:516:61: ','
				{
				DebugLocation(516, 61);
				char_literal488=(IToken)Match(input,91,Follow._91_in_global_attribute3892); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal488_tree = (object)adaptor.Create(char_literal488);
				adaptor.AddChild(root_0, char_literal488_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(133); }

			DebugLocation(516, 68);
			char_literal489=(IToken)Match(input,89,Follow._89_in_global_attribute3897); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal489_tree = (object)adaptor.Create(char_literal489);
			adaptor.AddChild(root_0, char_literal489_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("global_attribute", 134);
			LeaveRule("global_attribute", 134);
			Leave_global_attribute();
			if (state.backtracking > 0) { Memoize(input, 134, global_attribute_StartIndex); }
		}
		DebugLocation(516, 71);
		} finally { DebugExitRule(GrammarFileName, "global_attribute"); }
		return retval;

	}
	// $ANTLR end "global_attribute"

	public class global_attribute_target_specifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_global_attribute_target_specifier();
	partial void Leave_global_attribute_target_specifier();

	// $ANTLR start "global_attribute_target_specifier"
	// cs.g:517:8: public global_attribute_target_specifier : global_attribute_target ':' ;
	[GrammarRule("global_attribute_target_specifier")]
	public csParser.global_attribute_target_specifier_return global_attribute_target_specifier()
	{
		Enter_global_attribute_target_specifier();
		EnterRule("global_attribute_target_specifier", 135);
		TraceIn("global_attribute_target_specifier", 135);
		csParser.global_attribute_target_specifier_return retval = new csParser.global_attribute_target_specifier_return();
		retval.Start = (IToken)input.LT(1);
		int global_attribute_target_specifier_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal491=null;
		csParser.global_attribute_target_return global_attribute_target490 = default(csParser.global_attribute_target_return);

		object char_literal491_tree=null;

		try { DebugEnterRule(GrammarFileName, "global_attribute_target_specifier");
		DebugLocation(517, 31);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 135)) { return retval; }
			// cs.g:517:41: ( global_attribute_target ':' )
			DebugEnterAlt(1);
			// cs.g:518:2: global_attribute_target ':'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(518, 2);
			PushFollow(Follow._global_attribute_target_in_global_attribute_target_specifier3908);
			global_attribute_target490=global_attribute_target();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, global_attribute_target490.Tree);
			DebugLocation(518, 28);
			char_literal491=(IToken)Match(input,92,Follow._92_in_global_attribute_target_specifier3912); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal491_tree = (object)adaptor.Create(char_literal491);
			adaptor.AddChild(root_0, char_literal491_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("global_attribute_target_specifier", 135);
			LeaveRule("global_attribute_target_specifier", 135);
			Leave_global_attribute_target_specifier();
			if (state.backtracking > 0) { Memoize(input, 135, global_attribute_target_specifier_StartIndex); }
		}
		DebugLocation(518, 31);
		} finally { DebugExitRule(GrammarFileName, "global_attribute_target_specifier"); }
		return retval;

	}
	// $ANTLR end "global_attribute_target_specifier"

	public class global_attribute_target_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_global_attribute_target();
	partial void Leave_global_attribute_target();

	// $ANTLR start "global_attribute_target"
	// cs.g:519:8: public global_attribute_target : ( 'assembly' | 'module' );
	[GrammarRule("global_attribute_target")]
	public csParser.global_attribute_target_return global_attribute_target()
	{
		Enter_global_attribute_target();
		EnterRule("global_attribute_target", 136);
		TraceIn("global_attribute_target", 136);
		csParser.global_attribute_target_return retval = new csParser.global_attribute_target_return();
		retval.Start = (IToken)input.LT(1);
		int global_attribute_target_StartIndex = input.Index;
		object root_0 = null;

		IToken set492=null;

		object set492_tree=null;

		try { DebugEnterRule(GrammarFileName, "global_attribute_target");
		DebugLocation(519, 23);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 136)) { return retval; }
			// cs.g:519:31: ( 'assembly' | 'module' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(519, 31);
			set492=(IToken)input.LT(1);
			if ((input.LA(1)>=146 && input.LA(1)<=147))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set492));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("global_attribute_target", 136);
			LeaveRule("global_attribute_target", 136);
			Leave_global_attribute_target();
			if (state.backtracking > 0) { Memoize(input, 136, global_attribute_target_StartIndex); }
		}
		DebugLocation(520, 23);
		} finally { DebugExitRule(GrammarFileName, "global_attribute_target"); }
		return retval;

	}
	// $ANTLR end "global_attribute_target"

	public class attributes_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_attributes();
	partial void Leave_attributes();

	// $ANTLR start "attributes"
	// cs.g:521:8: public attributes : attribute_sections ;
	[GrammarRule("attributes")]
	public csParser.attributes_return attributes()
	{
		Enter_attributes();
		EnterRule("attributes", 137);
		TraceIn("attributes", 137);
		csParser.attributes_return retval = new csParser.attributes_return();
		retval.Start = (IToken)input.LT(1);
		int attributes_StartIndex = input.Index;
		object root_0 = null;

		csParser.attribute_sections_return attribute_sections493 = default(csParser.attribute_sections_return);


		try { DebugEnterRule(GrammarFileName, "attributes");
		DebugLocation(521, 20);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 137)) { return retval; }
			// cs.g:521:18: ( attribute_sections )
			DebugEnterAlt(1);
			// cs.g:522:2: attribute_sections
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(522, 2);
			PushFollow(Follow._attribute_sections_in_attributes3938);
			attribute_sections493=attribute_sections();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_sections493.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("attributes", 137);
			LeaveRule("attributes", 137);
			Leave_attributes();
			if (state.backtracking > 0) { Memoize(input, 137, attributes_StartIndex); }
		}
		DebugLocation(522, 20);
		} finally { DebugExitRule(GrammarFileName, "attributes"); }
		return retval;

	}
	// $ANTLR end "attributes"

	public class attribute_sections_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_attribute_sections();
	partial void Leave_attribute_sections();

	// $ANTLR start "attribute_sections"
	// cs.g:523:8: public attribute_sections : ( attribute_section )+ ;
	[GrammarRule("attribute_sections")]
	public csParser.attribute_sections_return attribute_sections()
	{
		Enter_attribute_sections();
		EnterRule("attribute_sections", 138);
		TraceIn("attribute_sections", 138);
		csParser.attribute_sections_return retval = new csParser.attribute_sections_return();
		retval.Start = (IToken)input.LT(1);
		int attribute_sections_StartIndex = input.Index;
		object root_0 = null;

		csParser.attribute_section_return attribute_section494 = default(csParser.attribute_section_return);


		try { DebugEnterRule(GrammarFileName, "attribute_sections");
		DebugLocation(523, 20);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 138)) { return retval; }
			// cs.g:523:26: ( ( attribute_section )+ )
			DebugEnterAlt(1);
			// cs.g:524:2: ( attribute_section )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(524, 2);
			// cs.g:524:2: ( attribute_section )+
			int cnt134=0;
			try { DebugEnterSubRule(134);
			while (true)
			{
				int alt134=2;
				try { DebugEnterDecision(134, decisionCanBacktrack[134]);
				int LA134_0 = input.LA(1);

				if ((LA134_0==88))
				{
					alt134=1;
				}


				} finally { DebugExitDecision(134); }
				switch (alt134)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:524:2: attribute_section
					{
					DebugLocation(524, 2);
					PushFollow(Follow._attribute_section_in_attribute_sections3949);
					attribute_section494=attribute_section();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_section494.Tree);

					}
					break;

				default:
					if (cnt134 >= 1)
						goto loop134;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee134 = new EarlyExitException( 134, input );
					DebugRecognitionException(eee134);
					throw eee134;
				}
				cnt134++;
			}
			loop134:
				;

			} finally { DebugExitSubRule(134); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("attribute_sections", 138);
			LeaveRule("attribute_sections", 138);
			Leave_attribute_sections();
			if (state.backtracking > 0) { Memoize(input, 138, attribute_sections_StartIndex); }
		}
		DebugLocation(524, 20);
		} finally { DebugExitRule(GrammarFileName, "attribute_sections"); }
		return retval;

	}
	// $ANTLR end "attribute_sections"

	public class attribute_section_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_attribute_section();
	partial void Leave_attribute_section();

	// $ANTLR start "attribute_section"
	// cs.g:525:8: public attribute_section : '[' ( attribute_target_specifier )? attribute_list ( ',' )? ']' ;
	[GrammarRule("attribute_section")]
	public csParser.attribute_section_return attribute_section()
	{
		Enter_attribute_section();
		EnterRule("attribute_section", 139);
		TraceIn("attribute_section", 139);
		csParser.attribute_section_return retval = new csParser.attribute_section_return();
		retval.Start = (IToken)input.LT(1);
		int attribute_section_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal495=null;
		IToken char_literal498=null;
		IToken char_literal499=null;
		csParser.attribute_target_specifier_return attribute_target_specifier496 = default(csParser.attribute_target_specifier_return);
		csParser.attribute_list_return attribute_list497 = default(csParser.attribute_list_return);

		object char_literal495_tree=null;
		object char_literal498_tree=null;
		object char_literal499_tree=null;

		try { DebugEnterRule(GrammarFileName, "attribute_section");
		DebugLocation(525, 65);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 139)) { return retval; }
			// cs.g:525:25: ( '[' ( attribute_target_specifier )? attribute_list ( ',' )? ']' )
			DebugEnterAlt(1);
			// cs.g:526:2: '[' ( attribute_target_specifier )? attribute_list ( ',' )? ']'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(526, 2);
			char_literal495=(IToken)Match(input,88,Follow._88_in_attribute_section3961); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal495_tree = (object)adaptor.Create(char_literal495);
			adaptor.AddChild(root_0, char_literal495_tree);
			}
			DebugLocation(526, 8);
			// cs.g:526:8: ( attribute_target_specifier )?
			int alt135=2;
			try { DebugEnterSubRule(135);
			try { DebugEnterDecision(135, decisionCanBacktrack[135]);
			int LA135_0 = input.LA(1);

			if ((LA135_0==148||(LA135_0>=150 && LA135_0<=152)||LA135_0==154))
			{
				int LA135_1 = input.LA(2);

				if ((LA135_1==92))
				{
					alt135=1;
				}
			}
			else if ((LA135_0==149||LA135_0==153))
			{
				alt135=1;
			}
			} finally { DebugExitDecision(135); }
			switch (alt135)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:526:8: attribute_target_specifier
				{
				DebugLocation(526, 8);
				PushFollow(Follow._attribute_target_specifier_in_attribute_section3965);
				attribute_target_specifier496=attribute_target_specifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_target_specifier496.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(135); }

			DebugLocation(526, 38);
			PushFollow(Follow._attribute_list_in_attribute_section3970);
			attribute_list497=attribute_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_list497.Tree);
			DebugLocation(526, 55);
			// cs.g:526:55: ( ',' )?
			int alt136=2;
			try { DebugEnterSubRule(136);
			try { DebugEnterDecision(136, decisionCanBacktrack[136]);
			int LA136_0 = input.LA(1);

			if ((LA136_0==91))
			{
				alt136=1;
			}
			} finally { DebugExitDecision(136); }
			switch (alt136)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:526:55: ','
				{
				DebugLocation(526, 55);
				char_literal498=(IToken)Match(input,91,Follow._91_in_attribute_section3974); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal498_tree = (object)adaptor.Create(char_literal498);
				adaptor.AddChild(root_0, char_literal498_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(136); }

			DebugLocation(526, 62);
			char_literal499=(IToken)Match(input,89,Follow._89_in_attribute_section3979); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal499_tree = (object)adaptor.Create(char_literal499);
			adaptor.AddChild(root_0, char_literal499_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("attribute_section", 139);
			LeaveRule("attribute_section", 139);
			Leave_attribute_section();
			if (state.backtracking > 0) { Memoize(input, 139, attribute_section_StartIndex); }
		}
		DebugLocation(526, 65);
		} finally { DebugExitRule(GrammarFileName, "attribute_section"); }
		return retval;

	}
	// $ANTLR end "attribute_section"

	public class attribute_target_specifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_attribute_target_specifier();
	partial void Leave_attribute_target_specifier();

	// $ANTLR start "attribute_target_specifier"
	// cs.g:527:8: public attribute_target_specifier : attribute_target ':' ;
	[GrammarRule("attribute_target_specifier")]
	public csParser.attribute_target_specifier_return attribute_target_specifier()
	{
		Enter_attribute_target_specifier();
		EnterRule("attribute_target_specifier", 140);
		TraceIn("attribute_target_specifier", 140);
		csParser.attribute_target_specifier_return retval = new csParser.attribute_target_specifier_return();
		retval.Start = (IToken)input.LT(1);
		int attribute_target_specifier_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal501=null;
		csParser.attribute_target_return attribute_target500 = default(csParser.attribute_target_return);

		object char_literal501_tree=null;

		try { DebugEnterRule(GrammarFileName, "attribute_target_specifier");
		DebugLocation(527, 24);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 140)) { return retval; }
			// cs.g:527:34: ( attribute_target ':' )
			DebugEnterAlt(1);
			// cs.g:528:2: attribute_target ':'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(528, 2);
			PushFollow(Follow._attribute_target_in_attribute_target_specifier3990);
			attribute_target500=attribute_target();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_target500.Tree);
			DebugLocation(528, 21);
			char_literal501=(IToken)Match(input,92,Follow._92_in_attribute_target_specifier3994); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal501_tree = (object)adaptor.Create(char_literal501);
			adaptor.AddChild(root_0, char_literal501_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("attribute_target_specifier", 140);
			LeaveRule("attribute_target_specifier", 140);
			Leave_attribute_target_specifier();
			if (state.backtracking > 0) { Memoize(input, 140, attribute_target_specifier_StartIndex); }
		}
		DebugLocation(528, 24);
		} finally { DebugExitRule(GrammarFileName, "attribute_target_specifier"); }
		return retval;

	}
	// $ANTLR end "attribute_target_specifier"

	public class attribute_target_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_attribute_target();
	partial void Leave_attribute_target();

	// $ANTLR start "attribute_target"
	// cs.g:529:8: public attribute_target : ( 'field' | 'event' | 'method' | 'param' | 'property' | 'return' | 'type' );
	[GrammarRule("attribute_target")]
	public csParser.attribute_target_return attribute_target()
	{
		Enter_attribute_target();
		EnterRule("attribute_target", 141);
		TraceIn("attribute_target", 141);
		csParser.attribute_target_return retval = new csParser.attribute_target_return();
		retval.Start = (IToken)input.LT(1);
		int attribute_target_StartIndex = input.Index;
		object root_0 = null;

		IToken set502=null;

		object set502_tree=null;

		try { DebugEnterRule(GrammarFileName, "attribute_target");
		DebugLocation(529, 73);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 141)) { return retval; }
			// cs.g:529:24: ( 'field' | 'event' | 'method' | 'param' | 'property' | 'return' | 'type' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(529, 24);
			set502=(IToken)input.LT(1);
			if ((input.LA(1)>=148 && input.LA(1)<=154))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set502));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("attribute_target", 141);
			LeaveRule("attribute_target", 141);
			Leave_attribute_target();
			if (state.backtracking > 0) { Memoize(input, 141, attribute_target_StartIndex); }
		}
		DebugLocation(530, 73);
		} finally { DebugExitRule(GrammarFileName, "attribute_target"); }
		return retval;

	}
	// $ANTLR end "attribute_target"

	public class attribute_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_attribute_list();
	partial void Leave_attribute_list();

	// $ANTLR start "attribute_list"
	// cs.g:531:8: public attribute_list : attribute ( ',' attribute )* ;
	[GrammarRule("attribute_list")]
	public csParser.attribute_list_return attribute_list()
	{
		Enter_attribute_list();
		EnterRule("attribute_list", 142);
		TraceIn("attribute_list", 142);
		csParser.attribute_list_return retval = new csParser.attribute_list_return();
		retval.Start = (IToken)input.LT(1);
		int attribute_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal504=null;
		csParser.attribute_return attribute503 = default(csParser.attribute_return);
		csParser.attribute_return attribute505 = default(csParser.attribute_return);

		object char_literal504_tree=null;

		try { DebugEnterRule(GrammarFileName, "attribute_list");
		DebugLocation(531, 28);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 142)) { return retval; }
			// cs.g:531:22: ( attribute ( ',' attribute )* )
			DebugEnterAlt(1);
			// cs.g:532:2: attribute ( ',' attribute )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(532, 2);
			PushFollow(Follow._attribute_in_attribute_list4040);
			attribute503=attribute();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute503.Tree);
			DebugLocation(532, 12);
			// cs.g:532:12: ( ',' attribute )*
			try { DebugEnterSubRule(137);
			while (true)
			{
				int alt137=2;
				try { DebugEnterDecision(137, decisionCanBacktrack[137]);
				int LA137_0 = input.LA(1);

				if ((LA137_0==91))
				{
					int LA137_1 = input.LA(2);

					if ((LA137_1==IDENTIFIER||(LA137_1>=ELIF && LA137_1<=UNDEF)||LA137_1==65||(LA137_1>=132 && LA137_1<=133)||(LA137_1>=135 && LA137_1<=148)||(LA137_1>=150 && LA137_1<=152)||LA137_1==154||(LA137_1>=156 && LA137_1<=159)||LA137_1==170||(LA137_1>=177 && LA137_1<=178)||LA137_1==195||LA137_1==202))
					{
						alt137=1;
					}


				}


				} finally { DebugExitDecision(137); }
				switch ( alt137 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:532:13: ',' attribute
					{
					DebugLocation(532, 13);
					char_literal504=(IToken)Match(input,91,Follow._91_in_attribute_list4043); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal504_tree = (object)adaptor.Create(char_literal504);
					adaptor.AddChild(root_0, char_literal504_tree);
					}
					DebugLocation(532, 17);
					PushFollow(Follow._attribute_in_attribute_list4045);
					attribute505=attribute();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute505.Tree);

					}
					break;

				default:
					goto loop137;
				}
			}

			loop137:
				;

			} finally { DebugExitSubRule(137); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("attribute_list", 142);
			LeaveRule("attribute_list", 142);
			Leave_attribute_list();
			if (state.backtracking > 0) { Memoize(input, 142, attribute_list_StartIndex); }
		}
		DebugLocation(532, 28);
		} finally { DebugExitRule(GrammarFileName, "attribute_list"); }
		return retval;

	}
	// $ANTLR end "attribute_list"

	public class attribute_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_attribute();
	partial void Leave_attribute();

	// $ANTLR start "attribute"
	// cs.g:533:8: public attribute : type_name ( attribute_arguments )? ;
	[GrammarRule("attribute")]
	public csParser.attribute_return attribute()
	{
		Enter_attribute();
		EnterRule("attribute", 143);
		TraceIn("attribute", 143);
		csParser.attribute_return retval = new csParser.attribute_return();
		retval.Start = (IToken)input.LT(1);
		int attribute_StartIndex = input.Index;
		object root_0 = null;

		csParser.type_name_return type_name506 = default(csParser.type_name_return);
		csParser.attribute_arguments_return attribute_arguments507 = default(csParser.attribute_arguments_return);


		try { DebugEnterRule(GrammarFileName, "attribute");
		DebugLocation(533, 34);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 143)) { return retval; }
			// cs.g:533:17: ( type_name ( attribute_arguments )? )
			DebugEnterAlt(1);
			// cs.g:534:2: type_name ( attribute_arguments )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(534, 2);
			PushFollow(Follow._type_name_in_attribute4059);
			type_name506=type_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name506.Tree);
			DebugLocation(534, 14);
			// cs.g:534:14: ( attribute_arguments )?
			int alt138=2;
			try { DebugEnterSubRule(138);
			try { DebugEnterDecision(138, decisionCanBacktrack[138]);
			int LA138_0 = input.LA(1);

			if ((LA138_0==90))
			{
				alt138=1;
			}
			} finally { DebugExitDecision(138); }
			switch (alt138)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:534:14: attribute_arguments
				{
				DebugLocation(534, 14);
				PushFollow(Follow._attribute_arguments_in_attribute4063);
				attribute_arguments507=attribute_arguments();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_arguments507.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(138); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("attribute", 143);
			LeaveRule("attribute", 143);
			Leave_attribute();
			if (state.backtracking > 0) { Memoize(input, 143, attribute_StartIndex); }
		}
		DebugLocation(534, 34);
		} finally { DebugExitRule(GrammarFileName, "attribute"); }
		return retval;

	}
	// $ANTLR end "attribute"

	public class attribute_arguments_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_attribute_arguments();
	partial void Leave_attribute_arguments();

	// $ANTLR start "attribute_arguments"
	// cs.g:536:8: public attribute_arguments : '(' ( ')' | ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* ) ')' ) ;
	[GrammarRule("attribute_arguments")]
	public csParser.attribute_arguments_return attribute_arguments()
	{
		Enter_attribute_arguments();
		EnterRule("attribute_arguments", 144);
		TraceIn("attribute_arguments", 144);
		csParser.attribute_arguments_return retval = new csParser.attribute_arguments_return();
		retval.Start = (IToken)input.LT(1);
		int attribute_arguments_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal508=null;
		IToken char_literal509=null;
		IToken char_literal512=null;
		IToken char_literal514=null;
		csParser.positional_argument_return positional_argument510 = default(csParser.positional_argument_return);
		csParser.named_argument_return named_argument511 = default(csParser.named_argument_return);
		csParser.positional_argument_return positional_argument513 = default(csParser.positional_argument_return);

		object char_literal508_tree=null;
		object char_literal509_tree=null;
		object char_literal512_tree=null;
		object char_literal514_tree=null;

		try { DebugEnterRule(GrammarFileName, "attribute_arguments");
		DebugLocation(536, 5);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 144)) { return retval; }
			// cs.g:536:27: ( '(' ( ')' | ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* ) ')' ) )
			DebugEnterAlt(1);
			// cs.g:537:2: '(' ( ')' | ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* ) ')' )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(537, 2);
			char_literal508=(IToken)Match(input,90,Follow._90_in_attribute_arguments4076); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal508_tree = (object)adaptor.Create(char_literal508);
			adaptor.AddChild(root_0, char_literal508_tree);
			}
			DebugLocation(537, 8);
			// cs.g:537:8: ( ')' | ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* ) ')' )
			int alt140=2;
			try { DebugEnterSubRule(140);
			try { DebugEnterDecision(140, decisionCanBacktrack[140]);
			int LA140_0 = input.LA(1);

			if ((LA140_0==RPAREN))
			{
				alt140=1;
			}
			else if (((LA140_0>=IDENTIFIER && LA140_0<=NULL)||LA140_0==MINUS||(LA140_0>=ELIF && LA140_0<=UNDEF)||LA140_0==65||LA140_0==68||(LA140_0>=83 && LA140_0<=84)||(LA140_0>=86 && LA140_0<=87)||LA140_0==90||(LA140_0>=95 && LA140_0<=100)||LA140_0==102||(LA140_0>=104 && LA140_0<=106)||LA140_0==117||(LA140_0>=132 && LA140_0<=133)||(LA140_0>=135 && LA140_0<=148)||(LA140_0>=150 && LA140_0<=152)||LA140_0==154||(LA140_0>=156 && LA140_0<=168)||LA140_0==170||(LA140_0>=177 && LA140_0<=178)||(LA140_0>=195 && LA140_0<=202)))
			{
				alt140=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 140, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(140); }
			switch (alt140)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:537:9: ')'
				{
				DebugLocation(537, 9);
				char_literal509=(IToken)Match(input,RPAREN,Follow._RPAREN_in_attribute_arguments4081); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal509_tree = (object)adaptor.Create(char_literal509);
				adaptor.AddChild(root_0, char_literal509_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:538:8: ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* ) ')'
				{
				DebugLocation(538, 8);
				// cs.g:538:8: ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* )
				DebugEnterAlt(1);
				// cs.g:538:9: positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )*
				{
				DebugLocation(538, 9);
				PushFollow(Follow._positional_argument_in_attribute_arguments4101);
				positional_argument510=positional_argument();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, positional_argument510.Tree);
				DebugLocation(538, 31);
				// cs.g:538:31: ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )*
				try { DebugEnterSubRule(139);
				while (true)
				{
					int alt139=3;
					try { DebugEnterDecision(139, decisionCanBacktrack[139]);
					int LA139_0 = input.LA(1);

					if ((LA139_0==IDENTIFIER) && (EvaluatePredicate(synpred24_cs_fragment)))
					{
						alt139=1;
					}
					else if (((LA139_0>=ELIF && LA139_0<=UNDEF)||LA139_0==65||(LA139_0>=132 && LA139_0<=133)||(LA139_0>=135 && LA139_0<=148)||(LA139_0>=150 && LA139_0<=152)||LA139_0==154||(LA139_0>=156 && LA139_0<=159)||LA139_0==170||(LA139_0>=177 && LA139_0<=178)||LA139_0==195||LA139_0==202) && (EvaluatePredicate(synpred24_cs_fragment)))
					{
						alt139=1;
					}
					else if ((LA139_0==91))
					{
						alt139=2;
					}


					} finally { DebugExitDecision(139); }
					switch ( alt139 )
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:538:32: ( ',' identifier '=' )=> named_argument
						{
						DebugLocation(538, 60);
						PushFollow(Follow._named_argument_in_attribute_arguments4120);
						named_argument511=named_argument();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, named_argument511.Tree);

						}
						break;
					case 2:
						DebugEnterAlt(2);
						// cs.g:539:15: ',' positional_argument
						{
						DebugLocation(539, 15);
						char_literal512=(IToken)Match(input,91,Follow._91_in_attribute_arguments4136); if (state.failed) return retval;
						if ( state.backtracking==0 ) {
						char_literal512_tree = (object)adaptor.Create(char_literal512);
						adaptor.AddChild(root_0, char_literal512_tree);
						}
						DebugLocation(539, 19);
						PushFollow(Follow._positional_argument_in_attribute_arguments4138);
						positional_argument513=positional_argument();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, positional_argument513.Tree);

						}
						break;

					default:
						goto loop139;
					}
				}

				loop139:
					;

				} finally { DebugExitSubRule(139); }


				}

				DebugLocation(540, 8);
				char_literal514=(IToken)Match(input,RPAREN,Follow._RPAREN_in_attribute_arguments4149); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal514_tree = (object)adaptor.Create(char_literal514);
				adaptor.AddChild(root_0, char_literal514_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(140); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("attribute_arguments", 144);
			LeaveRule("attribute_arguments", 144);
			Leave_attribute_arguments();
			if (state.backtracking > 0) { Memoize(input, 144, attribute_arguments_StartIndex); }
		}
		DebugLocation(541, 5);
		} finally { DebugExitRule(GrammarFileName, "attribute_arguments"); }
		return retval;

	}
	// $ANTLR end "attribute_arguments"

	public class positional_argument_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_positional_argument_list();
	partial void Leave_positional_argument_list();

	// $ANTLR start "positional_argument_list"
	// cs.g:542:8: public positional_argument_list : positional_argument ( ',' positional_argument )* ;
	[GrammarRule("positional_argument_list")]
	public csParser.positional_argument_list_return positional_argument_list()
	{
		Enter_positional_argument_list();
		EnterRule("positional_argument_list", 145);
		TraceIn("positional_argument_list", 145);
		csParser.positional_argument_list_return retval = new csParser.positional_argument_list_return();
		retval.Start = (IToken)input.LT(1);
		int positional_argument_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal516=null;
		csParser.positional_argument_return positional_argument515 = default(csParser.positional_argument_return);
		csParser.positional_argument_return positional_argument517 = default(csParser.positional_argument_return);

		object char_literal516_tree=null;

		try { DebugEnterRule(GrammarFileName, "positional_argument_list");
		DebugLocation(542, 48);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 145)) { return retval; }
			// cs.g:542:32: ( positional_argument ( ',' positional_argument )* )
			DebugEnterAlt(1);
			// cs.g:543:2: positional_argument ( ',' positional_argument )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(543, 2);
			PushFollow(Follow._positional_argument_in_positional_argument_list4165);
			positional_argument515=positional_argument();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, positional_argument515.Tree);
			DebugLocation(543, 22);
			// cs.g:543:22: ( ',' positional_argument )*
			try { DebugEnterSubRule(141);
			while (true)
			{
				int alt141=2;
				try { DebugEnterDecision(141, decisionCanBacktrack[141]);
				int LA141_0 = input.LA(1);

				if ((LA141_0==91))
				{
					alt141=1;
				}


				} finally { DebugExitDecision(141); }
				switch ( alt141 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:543:23: ',' positional_argument
					{
					DebugLocation(543, 23);
					char_literal516=(IToken)Match(input,91,Follow._91_in_positional_argument_list4168); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal516_tree = (object)adaptor.Create(char_literal516);
					adaptor.AddChild(root_0, char_literal516_tree);
					}
					DebugLocation(543, 27);
					PushFollow(Follow._positional_argument_in_positional_argument_list4170);
					positional_argument517=positional_argument();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, positional_argument517.Tree);

					}
					break;

				default:
					goto loop141;
				}
			}

			loop141:
				;

			} finally { DebugExitSubRule(141); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("positional_argument_list", 145);
			LeaveRule("positional_argument_list", 145);
			Leave_positional_argument_list();
			if (state.backtracking > 0) { Memoize(input, 145, positional_argument_list_StartIndex); }
		}
		DebugLocation(543, 48);
		} finally { DebugExitRule(GrammarFileName, "positional_argument_list"); }
		return retval;

	}
	// $ANTLR end "positional_argument_list"

	public class positional_argument_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_positional_argument();
	partial void Leave_positional_argument();

	// $ANTLR start "positional_argument"
	// cs.g:544:8: public positional_argument : attribute_argument_expression ;
	[GrammarRule("positional_argument")]
	public csParser.positional_argument_return positional_argument()
	{
		Enter_positional_argument();
		EnterRule("positional_argument", 146);
		TraceIn("positional_argument", 146);
		csParser.positional_argument_return retval = new csParser.positional_argument_return();
		retval.Start = (IToken)input.LT(1);
		int positional_argument_StartIndex = input.Index;
		object root_0 = null;

		csParser.attribute_argument_expression_return attribute_argument_expression518 = default(csParser.attribute_argument_expression_return);


		try { DebugEnterRule(GrammarFileName, "positional_argument");
		DebugLocation(544, 31);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 146)) { return retval; }
			// cs.g:544:27: ( attribute_argument_expression )
			DebugEnterAlt(1);
			// cs.g:545:2: attribute_argument_expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(545, 2);
			PushFollow(Follow._attribute_argument_expression_in_positional_argument4183);
			attribute_argument_expression518=attribute_argument_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_argument_expression518.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("positional_argument", 146);
			LeaveRule("positional_argument", 146);
			Leave_positional_argument();
			if (state.backtracking > 0) { Memoize(input, 146, positional_argument_StartIndex); }
		}
		DebugLocation(545, 31);
		} finally { DebugExitRule(GrammarFileName, "positional_argument"); }
		return retval;

	}
	// $ANTLR end "positional_argument"

	public class named_argument_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_named_argument_list();
	partial void Leave_named_argument_list();

	// $ANTLR start "named_argument_list"
	// cs.g:546:8: public named_argument_list : named_argument ( ',' named_argument )* ;
	[GrammarRule("named_argument_list")]
	public csParser.named_argument_list_return named_argument_list()
	{
		Enter_named_argument_list();
		EnterRule("named_argument_list", 147);
		TraceIn("named_argument_list", 147);
		csParser.named_argument_list_return retval = new csParser.named_argument_list_return();
		retval.Start = (IToken)input.LT(1);
		int named_argument_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal520=null;
		csParser.named_argument_return named_argument519 = default(csParser.named_argument_return);
		csParser.named_argument_return named_argument521 = default(csParser.named_argument_return);

		object char_literal520_tree=null;

		try { DebugEnterRule(GrammarFileName, "named_argument_list");
		DebugLocation(546, 38);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 147)) { return retval; }
			// cs.g:546:27: ( named_argument ( ',' named_argument )* )
			DebugEnterAlt(1);
			// cs.g:547:2: named_argument ( ',' named_argument )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(547, 2);
			PushFollow(Follow._named_argument_in_named_argument_list4194);
			named_argument519=named_argument();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, named_argument519.Tree);
			DebugLocation(547, 17);
			// cs.g:547:17: ( ',' named_argument )*
			try { DebugEnterSubRule(142);
			while (true)
			{
				int alt142=2;
				try { DebugEnterDecision(142, decisionCanBacktrack[142]);
				int LA142_0 = input.LA(1);

				if ((LA142_0==91))
				{
					alt142=1;
				}


				} finally { DebugExitDecision(142); }
				switch ( alt142 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:547:18: ',' named_argument
					{
					DebugLocation(547, 18);
					char_literal520=(IToken)Match(input,91,Follow._91_in_named_argument_list4197); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal520_tree = (object)adaptor.Create(char_literal520);
					adaptor.AddChild(root_0, char_literal520_tree);
					}
					DebugLocation(547, 22);
					PushFollow(Follow._named_argument_in_named_argument_list4199);
					named_argument521=named_argument();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, named_argument521.Tree);

					}
					break;

				default:
					goto loop142;
				}
			}

			loop142:
				;

			} finally { DebugExitSubRule(142); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("named_argument_list", 147);
			LeaveRule("named_argument_list", 147);
			Leave_named_argument_list();
			if (state.backtracking > 0) { Memoize(input, 147, named_argument_list_StartIndex); }
		}
		DebugLocation(547, 38);
		} finally { DebugExitRule(GrammarFileName, "named_argument_list"); }
		return retval;

	}
	// $ANTLR end "named_argument_list"

	public class named_argument_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_named_argument();
	partial void Leave_named_argument();

	// $ANTLR start "named_argument"
	// cs.g:548:8: public named_argument : identifier '=' attribute_argument_expression ;
	[GrammarRule("named_argument")]
	public csParser.named_argument_return named_argument()
	{
		Enter_named_argument();
		EnterRule("named_argument", 148);
		TraceIn("named_argument", 148);
		csParser.named_argument_return retval = new csParser.named_argument_return();
		retval.Start = (IToken)input.LT(1);
		int named_argument_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal523=null;
		csParser.identifier_return identifier522 = default(csParser.identifier_return);
		csParser.attribute_argument_expression_return attribute_argument_expression524 = default(csParser.attribute_argument_expression_return);

		object char_literal523_tree=null;

		try { DebugEnterRule(GrammarFileName, "named_argument");
		DebugLocation(548, 50);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 148)) { return retval; }
			// cs.g:548:22: ( identifier '=' attribute_argument_expression )
			DebugEnterAlt(1);
			// cs.g:549:2: identifier '=' attribute_argument_expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(549, 2);
			PushFollow(Follow._identifier_in_named_argument4212);
			identifier522=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier522.Tree);
			DebugLocation(549, 15);
			char_literal523=(IToken)Match(input,66,Follow._66_in_named_argument4216); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal523_tree = (object)adaptor.Create(char_literal523);
			adaptor.AddChild(root_0, char_literal523_tree);
			}
			DebugLocation(549, 21);
			PushFollow(Follow._attribute_argument_expression_in_named_argument4220);
			attribute_argument_expression524=attribute_argument_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_argument_expression524.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("named_argument", 148);
			LeaveRule("named_argument", 148);
			Leave_named_argument();
			if (state.backtracking > 0) { Memoize(input, 148, named_argument_StartIndex); }
		}
		DebugLocation(549, 50);
		} finally { DebugExitRule(GrammarFileName, "named_argument"); }
		return retval;

	}
	// $ANTLR end "named_argument"

	public class attribute_argument_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_attribute_argument_expression();
	partial void Leave_attribute_argument_expression();

	// $ANTLR start "attribute_argument_expression"
	// cs.g:550:8: public attribute_argument_expression : expression ;
	[GrammarRule("attribute_argument_expression")]
	public csParser.attribute_argument_expression_return attribute_argument_expression()
	{
		Enter_attribute_argument_expression();
		EnterRule("attribute_argument_expression", 149);
		TraceIn("attribute_argument_expression", 149);
		csParser.attribute_argument_expression_return retval = new csParser.attribute_argument_expression_return();
		retval.Start = (IToken)input.LT(1);
		int attribute_argument_expression_StartIndex = input.Index;
		object root_0 = null;

		csParser.expression_return expression525 = default(csParser.expression_return);


		try { DebugEnterRule(GrammarFileName, "attribute_argument_expression");
		DebugLocation(550, 12);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 149)) { return retval; }
			// cs.g:550:37: ( expression )
			DebugEnterAlt(1);
			// cs.g:551:2: expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(551, 2);
			PushFollow(Follow._expression_in_attribute_argument_expression4231);
			expression525=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression525.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("attribute_argument_expression", 149);
			LeaveRule("attribute_argument_expression", 149);
			Leave_attribute_argument_expression();
			if (state.backtracking > 0) { Memoize(input, 149, attribute_argument_expression_StartIndex); }
		}
		DebugLocation(551, 12);
		} finally { DebugExitRule(GrammarFileName, "attribute_argument_expression"); }
		return retval;

	}
	// $ANTLR end "attribute_argument_expression"

	public class class_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_class_declaration();
	partial void Leave_class_declaration();

	// $ANTLR start "class_declaration"
	// cs.g:557:8: public class_declaration : 'class' type_or_generic ( class_base )? ( type_parameter_constraints_clauses )? class_body ( ';' )? ;
	[GrammarRule("class_declaration")]
	public csParser.class_declaration_return class_declaration()
	{
		Enter_class_declaration();
		EnterRule("class_declaration", 150);
		TraceIn("class_declaration", 150);
		csParser.class_declaration_return retval = new csParser.class_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int class_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal526=null;
		IToken char_literal531=null;
		csParser.type_or_generic_return type_or_generic527 = default(csParser.type_or_generic_return);
		csParser.class_base_return class_base528 = default(csParser.class_base_return);
		csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses529 = default(csParser.type_parameter_constraints_clauses_return);
		csParser.class_body_return class_body530 = default(csParser.class_body_return);

		object string_literal526_tree=null;
		object char_literal531_tree=null;

		try { DebugEnterRule(GrammarFileName, "class_declaration");
		DebugLocation(557, 98);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 150)) { return retval; }
			// cs.g:557:25: ( 'class' type_or_generic ( class_base )? ( type_parameter_constraints_clauses )? class_body ( ';' )? )
			DebugEnterAlt(1);
			// cs.g:558:2: 'class' type_or_generic ( class_base )? ( type_parameter_constraints_clauses )? class_body ( ';' )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(558, 2);
			string_literal526=(IToken)Match(input,155,Follow._155_in_class_declaration4246); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal526_tree = (object)adaptor.Create(string_literal526);
			adaptor.AddChild(root_0, string_literal526_tree);
			}
			DebugLocation(558, 11);
			PushFollow(Follow._type_or_generic_in_class_declaration4249);
			type_or_generic527=type_or_generic();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic527.Tree);
			DebugLocation(558, 29);
			// cs.g:558:29: ( class_base )?
			int alt143=2;
			try { DebugEnterSubRule(143);
			try { DebugEnterDecision(143, decisionCanBacktrack[143]);
			int LA143_0 = input.LA(1);

			if ((LA143_0==92))
			{
				alt143=1;
			}
			} finally { DebugExitDecision(143); }
			switch (alt143)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:558:29: class_base
				{
				DebugLocation(558, 29);
				PushFollow(Follow._class_base_in_class_declaration4253);
				class_base528=class_base();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_base528.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(143); }

			DebugLocation(558, 43);
			// cs.g:558:43: ( type_parameter_constraints_clauses )?
			int alt144=2;
			try { DebugEnterSubRule(144);
			try { DebugEnterDecision(144, decisionCanBacktrack[144]);
			int LA144_0 = input.LA(1);

			if ((LA144_0==145))
			{
				alt144=1;
			}
			} finally { DebugExitDecision(144); }
			switch (alt144)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:558:43: type_parameter_constraints_clauses
				{
				DebugLocation(558, 43);
				PushFollow(Follow._type_parameter_constraints_clauses_in_class_declaration4258);
				type_parameter_constraints_clauses529=type_parameter_constraints_clauses();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses529.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(144); }

			DebugLocation(558, 81);
			PushFollow(Follow._class_body_in_class_declaration4263);
			class_body530=class_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_body530.Tree);
			DebugLocation(558, 94);
			// cs.g:558:94: ( ';' )?
			int alt145=2;
			try { DebugEnterSubRule(145);
			try { DebugEnterDecision(145, decisionCanBacktrack[145]);
			int LA145_0 = input.LA(1);

			if ((LA145_0==SEMI))
			{
				alt145=1;
			}
			} finally { DebugExitDecision(145); }
			switch (alt145)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:558:94: ';'
				{
				DebugLocation(558, 94);
				char_literal531=(IToken)Match(input,SEMI,Follow._SEMI_in_class_declaration4267); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal531_tree = (object)adaptor.Create(char_literal531);
				adaptor.AddChild(root_0, char_literal531_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(145); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("class_declaration", 150);
			LeaveRule("class_declaration", 150);
			Leave_class_declaration();
			if (state.backtracking > 0) { Memoize(input, 150, class_declaration_StartIndex); }
		}
		DebugLocation(558, 98);
		} finally { DebugExitRule(GrammarFileName, "class_declaration"); }
		return retval;

	}
	// $ANTLR end "class_declaration"

	public class class_base_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_class_base();
	partial void Leave_class_base();

	// $ANTLR start "class_base"
	// cs.g:559:8: public class_base : ':' interface_type_list ;
	[GrammarRule("class_base")]
	public csParser.class_base_return class_base()
	{
		Enter_class_base();
		EnterRule("class_base", 151);
		TraceIn("class_base", 151);
		csParser.class_base_return retval = new csParser.class_base_return();
		retval.Start = (IToken)input.LT(1);
		int class_base_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal532=null;
		csParser.interface_type_list_return interface_type_list533 = default(csParser.interface_type_list_return);

		object char_literal532_tree=null;

		try { DebugEnterRule(GrammarFileName, "class_base");
		DebugLocation(559, 27);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 151)) { return retval; }
			// cs.g:559:18: ( ':' interface_type_list )
			DebugEnterAlt(1);
			// cs.g:562:2: ':' interface_type_list
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(562, 2);
			char_literal532=(IToken)Match(input,92,Follow._92_in_class_base4282); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal532_tree = (object)adaptor.Create(char_literal532);
			adaptor.AddChild(root_0, char_literal532_tree);
			}
			DebugLocation(562, 8);
			PushFollow(Follow._interface_type_list_in_class_base4286);
			interface_type_list533=interface_type_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_type_list533.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("class_base", 151);
			LeaveRule("class_base", 151);
			Leave_class_base();
			if (state.backtracking > 0) { Memoize(input, 151, class_base_StartIndex); }
		}
		DebugLocation(562, 27);
		} finally { DebugExitRule(GrammarFileName, "class_base"); }
		return retval;

	}
	// $ANTLR end "class_base"

	public class interface_type_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_type_list();
	partial void Leave_interface_type_list();

	// $ANTLR start "interface_type_list"
	// cs.g:564:8: public interface_type_list : type ( ',' type )* ;
	[GrammarRule("interface_type_list")]
	public csParser.interface_type_list_return interface_type_list()
	{
		Enter_interface_type_list();
		EnterRule("interface_type_list", 152);
		TraceIn("interface_type_list", 152);
		csParser.interface_type_list_return retval = new csParser.interface_type_list_return();
		retval.Start = (IToken)input.LT(1);
		int interface_type_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal535=null;
		csParser.type_return type534 = default(csParser.type_return);
		csParser.type_return type536 = default(csParser.type_return);

		object char_literal535_tree=null;

		try { DebugEnterRule(GrammarFileName, "interface_type_list");
		DebugLocation(564, 20);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 152)) { return retval; }
			// cs.g:564:27: ( type ( ',' type )* )
			DebugEnterAlt(1);
			// cs.g:565:2: type ( ',' type )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(565, 2);
			PushFollow(Follow._type_in_interface_type_list4298);
			type534=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type534.Tree);
			DebugLocation(565, 7);
			// cs.g:565:7: ( ',' type )*
			try { DebugEnterSubRule(146);
			while (true)
			{
				int alt146=2;
				try { DebugEnterDecision(146, decisionCanBacktrack[146]);
				int LA146_0 = input.LA(1);

				if ((LA146_0==91))
				{
					alt146=1;
				}


				} finally { DebugExitDecision(146); }
				switch ( alt146 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:565:8: ',' type
					{
					DebugLocation(565, 8);
					char_literal535=(IToken)Match(input,91,Follow._91_in_interface_type_list4301); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal535_tree = (object)adaptor.Create(char_literal535);
					adaptor.AddChild(root_0, char_literal535_tree);
					}
					DebugLocation(565, 14);
					PushFollow(Follow._type_in_interface_type_list4305);
					type536=type();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type536.Tree);

					}
					break;

				default:
					goto loop146;
				}
			}

			loop146:
				;

			} finally { DebugExitSubRule(146); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_type_list", 152);
			LeaveRule("interface_type_list", 152);
			Leave_interface_type_list();
			if (state.backtracking > 0) { Memoize(input, 152, interface_type_list_StartIndex); }
		}
		DebugLocation(565, 20);
		} finally { DebugExitRule(GrammarFileName, "interface_type_list"); }
		return retval;

	}
	// $ANTLR end "interface_type_list"

	public class class_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_class_body();
	partial void Leave_class_body();

	// $ANTLR start "class_body"
	// cs.g:567:8: public class_body : '{' ( class_member_declarations )? '}' ;
	[GrammarRule("class_body")]
	public csParser.class_body_return class_body()
	{
		Enter_class_body();
		EnterRule("class_body", 153);
		TraceIn("class_body", 153);
		csParser.class_body_return retval = new csParser.class_body_return();
		retval.Start = (IToken)input.LT(1);
		int class_body_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal537=null;
		IToken char_literal539=null;
		csParser.class_member_declarations_return class_member_declarations538 = default(csParser.class_member_declarations_return);

		object char_literal537_tree=null;
		object char_literal539_tree=null;

		try { DebugEnterRule(GrammarFileName, "class_body");
		DebugLocation(567, 40);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 153)) { return retval; }
			// cs.g:567:18: ( '{' ( class_member_declarations )? '}' )
			DebugEnterAlt(1);
			// cs.g:568:2: '{' ( class_member_declarations )? '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(568, 2);
			char_literal537=(IToken)Match(input,62,Follow._62_in_class_body4318); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal537_tree = (object)adaptor.Create(char_literal537);
			adaptor.AddChild(root_0, char_literal537_tree);
			}
			DebugLocation(568, 8);
			// cs.g:568:8: ( class_member_declarations )?
			int alt147=2;
			try { DebugEnterSubRule(147);
			try { DebugEnterDecision(147, decisionCanBacktrack[147]);
			int LA147_0 = input.LA(1);

			if ((LA147_0==IDENTIFIER||LA147_0==ENUM||(LA147_0>=ELIF && LA147_0<=UNDEF)||(LA147_0>=64 && LA147_0<=65)||(LA147_0>=67 && LA147_0<=82)||LA147_0==88||LA147_0==99||LA147_0==106||(LA147_0>=132 && LA147_0<=133)||(LA147_0>=135 && LA147_0<=152)||(LA147_0>=154 && LA147_0<=170)||LA147_0==172||(LA147_0>=174 && LA147_0<=175)||(LA147_0>=177 && LA147_0<=178)||(LA147_0>=195 && LA147_0<=202)))
			{
				alt147=1;
			}
			} finally { DebugExitDecision(147); }
			switch (alt147)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:568:8: class_member_declarations
				{
				DebugLocation(568, 8);
				PushFollow(Follow._class_member_declarations_in_class_body4322);
				class_member_declarations538=class_member_declarations();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_member_declarations538.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(147); }

			DebugLocation(568, 37);
			char_literal539=(IToken)Match(input,63,Follow._63_in_class_body4327); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal539_tree = (object)adaptor.Create(char_literal539);
			adaptor.AddChild(root_0, char_literal539_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("class_body", 153);
			LeaveRule("class_body", 153);
			Leave_class_body();
			if (state.backtracking > 0) { Memoize(input, 153, class_body_StartIndex); }
		}
		DebugLocation(568, 40);
		} finally { DebugExitRule(GrammarFileName, "class_body"); }
		return retval;

	}
	// $ANTLR end "class_body"

	public class class_member_declarations_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_class_member_declarations();
	partial void Leave_class_member_declarations();

	// $ANTLR start "class_member_declarations"
	// cs.g:569:8: public class_member_declarations : ( class_member_declaration )+ ;
	[GrammarRule("class_member_declarations")]
	public csParser.class_member_declarations_return class_member_declarations()
	{
		Enter_class_member_declarations();
		EnterRule("class_member_declarations", 154);
		TraceIn("class_member_declarations", 154);
		csParser.class_member_declarations_return retval = new csParser.class_member_declarations_return();
		retval.Start = (IToken)input.LT(1);
		int class_member_declarations_StartIndex = input.Index;
		object root_0 = null;

		csParser.class_member_declaration_return class_member_declaration540 = default(csParser.class_member_declaration_return);


		try { DebugEnterRule(GrammarFileName, "class_member_declarations");
		DebugLocation(569, 27);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 154)) { return retval; }
			// cs.g:569:33: ( ( class_member_declaration )+ )
			DebugEnterAlt(1);
			// cs.g:570:2: ( class_member_declaration )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(570, 2);
			// cs.g:570:2: ( class_member_declaration )+
			int cnt148=0;
			try { DebugEnterSubRule(148);
			while (true)
			{
				int alt148=2;
				try { DebugEnterDecision(148, decisionCanBacktrack[148]);
				int LA148_0 = input.LA(1);

				if ((LA148_0==IDENTIFIER||LA148_0==ENUM||(LA148_0>=ELIF && LA148_0<=UNDEF)||(LA148_0>=64 && LA148_0<=65)||(LA148_0>=67 && LA148_0<=82)||LA148_0==88||LA148_0==99||LA148_0==106||(LA148_0>=132 && LA148_0<=133)||(LA148_0>=135 && LA148_0<=152)||(LA148_0>=154 && LA148_0<=170)||LA148_0==172||(LA148_0>=174 && LA148_0<=175)||(LA148_0>=177 && LA148_0<=178)||(LA148_0>=195 && LA148_0<=202)))
				{
					alt148=1;
				}


				} finally { DebugExitDecision(148); }
				switch (alt148)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:570:2: class_member_declaration
					{
					DebugLocation(570, 2);
					PushFollow(Follow._class_member_declaration_in_class_member_declarations4337);
					class_member_declaration540=class_member_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_member_declaration540.Tree);

					}
					break;

				default:
					if (cnt148 >= 1)
						goto loop148;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee148 = new EarlyExitException( 148, input );
					DebugRecognitionException(eee148);
					throw eee148;
				}
				cnt148++;
			}
			loop148:
				;

			} finally { DebugExitSubRule(148); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("class_member_declarations", 154);
			LeaveRule("class_member_declarations", 154);
			Leave_class_member_declarations();
			if (state.backtracking > 0) { Memoize(input, 154, class_member_declarations_StartIndex); }
		}
		DebugLocation(570, 27);
		} finally { DebugExitRule(GrammarFileName, "class_member_declarations"); }
		return retval;

	}
	// $ANTLR end "class_member_declarations"

	public class constant_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_constant_declaration();
	partial void Leave_constant_declaration();

	// $ANTLR start "constant_declaration"
	// cs.g:573:8: public constant_declaration : 'const' type constant_declarators ';' ;
	[GrammarRule("constant_declaration")]
	public csParser.constant_declaration_return constant_declaration()
	{
		Enter_constant_declaration();
		EnterRule("constant_declaration", 155);
		TraceIn("constant_declaration", 155);
		csParser.constant_declaration_return retval = new csParser.constant_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int constant_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal541=null;
		IToken char_literal544=null;
		csParser.type_return type542 = default(csParser.type_return);
		csParser.constant_declarators_return constant_declarators543 = default(csParser.constant_declarators_return);

		object string_literal541_tree=null;
		object char_literal544_tree=null;

		try { DebugEnterRule(GrammarFileName, "constant_declaration");
		DebugLocation(573, 45);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 155)) { return retval; }
			// cs.g:573:28: ( 'const' type constant_declarators ';' )
			DebugEnterAlt(1);
			// cs.g:574:2: 'const' type constant_declarators ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(574, 2);
			string_literal541=(IToken)Match(input,81,Follow._81_in_constant_declaration4350); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal541_tree = (object)adaptor.Create(string_literal541);
			adaptor.AddChild(root_0, string_literal541_tree);
			}
			DebugLocation(574, 12);
			PushFollow(Follow._type_in_constant_declaration4354);
			type542=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type542.Tree);
			DebugLocation(574, 19);
			PushFollow(Follow._constant_declarators_in_constant_declaration4358);
			constant_declarators543=constant_declarators();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarators543.Tree);
			DebugLocation(574, 42);
			char_literal544=(IToken)Match(input,SEMI,Follow._SEMI_in_constant_declaration4362); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal544_tree = (object)adaptor.Create(char_literal544);
			adaptor.AddChild(root_0, char_literal544_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("constant_declaration", 155);
			LeaveRule("constant_declaration", 155);
			Leave_constant_declaration();
			if (state.backtracking > 0) { Memoize(input, 155, constant_declaration_StartIndex); }
		}
		DebugLocation(574, 45);
		} finally { DebugExitRule(GrammarFileName, "constant_declaration"); }
		return retval;

	}
	// $ANTLR end "constant_declaration"

	public class constant_declarators_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_constant_declarators();
	partial void Leave_constant_declarators();

	// $ANTLR start "constant_declarators"
	// cs.g:575:8: public constant_declarators : constant_declarator ( ',' constant_declarator )* ;
	[GrammarRule("constant_declarators")]
	public csParser.constant_declarators_return constant_declarators()
	{
		Enter_constant_declarators();
		EnterRule("constant_declarators", 156);
		TraceIn("constant_declarators", 156);
		csParser.constant_declarators_return retval = new csParser.constant_declarators_return();
		retval.Start = (IToken)input.LT(1);
		int constant_declarators_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal546=null;
		csParser.constant_declarator_return constant_declarator545 = default(csParser.constant_declarator_return);
		csParser.constant_declarator_return constant_declarator547 = default(csParser.constant_declarator_return);

		object char_literal546_tree=null;

		try { DebugEnterRule(GrammarFileName, "constant_declarators");
		DebugLocation(575, 48);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 156)) { return retval; }
			// cs.g:575:28: ( constant_declarator ( ',' constant_declarator )* )
			DebugEnterAlt(1);
			// cs.g:576:2: constant_declarator ( ',' constant_declarator )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(576, 2);
			PushFollow(Follow._constant_declarator_in_constant_declarators4372);
			constant_declarator545=constant_declarator();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarator545.Tree);
			DebugLocation(576, 22);
			// cs.g:576:22: ( ',' constant_declarator )*
			try { DebugEnterSubRule(149);
			while (true)
			{
				int alt149=2;
				try { DebugEnterDecision(149, decisionCanBacktrack[149]);
				int LA149_0 = input.LA(1);

				if ((LA149_0==91))
				{
					alt149=1;
				}


				} finally { DebugExitDecision(149); }
				switch ( alt149 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:576:23: ',' constant_declarator
					{
					DebugLocation(576, 23);
					char_literal546=(IToken)Match(input,91,Follow._91_in_constant_declarators4375); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal546_tree = (object)adaptor.Create(char_literal546);
					adaptor.AddChild(root_0, char_literal546_tree);
					}
					DebugLocation(576, 27);
					PushFollow(Follow._constant_declarator_in_constant_declarators4377);
					constant_declarator547=constant_declarator();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarator547.Tree);

					}
					break;

				default:
					goto loop149;
				}
			}

			loop149:
				;

			} finally { DebugExitSubRule(149); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("constant_declarators", 156);
			LeaveRule("constant_declarators", 156);
			Leave_constant_declarators();
			if (state.backtracking > 0) { Memoize(input, 156, constant_declarators_StartIndex); }
		}
		DebugLocation(576, 48);
		} finally { DebugExitRule(GrammarFileName, "constant_declarators"); }
		return retval;

	}
	// $ANTLR end "constant_declarators"

	public class constant_declarator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_constant_declarator();
	partial void Leave_constant_declarator();

	// $ANTLR start "constant_declarator"
	// cs.g:577:8: public constant_declarator : identifier ( '=' constant_expression )? ;
	[GrammarRule("constant_declarator")]
	public csParser.constant_declarator_return constant_declarator()
	{
		Enter_constant_declarator();
		EnterRule("constant_declarator", 157);
		TraceIn("constant_declarator", 157);
		csParser.constant_declarator_return retval = new csParser.constant_declarator_return();
		retval.Start = (IToken)input.LT(1);
		int constant_declarator_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal549=null;
		csParser.identifier_return identifier548 = default(csParser.identifier_return);
		csParser.constant_expression_return constant_expression550 = default(csParser.constant_expression_return);

		object char_literal549_tree=null;

		try { DebugEnterRule(GrammarFileName, "constant_declarator");
		DebugLocation(577, 43);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 157)) { return retval; }
			// cs.g:577:27: ( identifier ( '=' constant_expression )? )
			DebugEnterAlt(1);
			// cs.g:578:2: identifier ( '=' constant_expression )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(578, 2);
			PushFollow(Follow._identifier_in_constant_declarator4389);
			identifier548=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier548.Tree);
			DebugLocation(578, 15);
			// cs.g:578:15: ( '=' constant_expression )?
			int alt150=2;
			try { DebugEnterSubRule(150);
			try { DebugEnterDecision(150, decisionCanBacktrack[150]);
			int LA150_0 = input.LA(1);

			if ((LA150_0==66))
			{
				alt150=1;
			}
			} finally { DebugExitDecision(150); }
			switch (alt150)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:578:16: '=' constant_expression
				{
				DebugLocation(578, 16);
				char_literal549=(IToken)Match(input,66,Follow._66_in_constant_declarator4394); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal549_tree = (object)adaptor.Create(char_literal549);
				adaptor.AddChild(root_0, char_literal549_tree);
				}
				DebugLocation(578, 22);
				PushFollow(Follow._constant_expression_in_constant_declarator4398);
				constant_expression550=constant_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_expression550.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(150); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("constant_declarator", 157);
			LeaveRule("constant_declarator", 157);
			Leave_constant_declarator();
			if (state.backtracking > 0) { Memoize(input, 157, constant_declarator_StartIndex); }
		}
		DebugLocation(578, 43);
		} finally { DebugExitRule(GrammarFileName, "constant_declarator"); }
		return retval;

	}
	// $ANTLR end "constant_declarator"

	public class constant_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_constant_expression();
	partial void Leave_constant_expression();

	// $ANTLR start "constant_expression"
	// cs.g:579:8: public constant_expression : expression ;
	[GrammarRule("constant_expression")]
	public csParser.constant_expression_return constant_expression()
	{
		Enter_constant_expression();
		EnterRule("constant_expression", 158);
		TraceIn("constant_expression", 158);
		csParser.constant_expression_return retval = new csParser.constant_expression_return();
		retval.Start = (IToken)input.LT(1);
		int constant_expression_StartIndex = input.Index;
		object root_0 = null;

		csParser.expression_return expression551 = default(csParser.expression_return);


		try { DebugEnterRule(GrammarFileName, "constant_expression");
		DebugLocation(579, 11);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 158)) { return retval; }
			// cs.g:579:27: ( expression )
			DebugEnterAlt(1);
			// cs.g:580:2: expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(580, 2);
			PushFollow(Follow._expression_in_constant_expression4410);
			expression551=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression551.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("constant_expression", 158);
			LeaveRule("constant_expression", 158);
			Leave_constant_expression();
			if (state.backtracking > 0) { Memoize(input, 158, constant_expression_StartIndex); }
		}
		DebugLocation(580, 11);
		} finally { DebugExitRule(GrammarFileName, "constant_expression"); }
		return retval;

	}
	// $ANTLR end "constant_expression"

	public class field_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_field_declaration();
	partial void Leave_field_declaration();

	// $ANTLR start "field_declaration"
	// cs.g:583:8: public field_declaration : variable_declarators ';' ;
	[GrammarRule("field_declaration")]
	public csParser.field_declaration_return field_declaration()
	{
		Enter_field_declaration();
		EnterRule("field_declaration", 159);
		TraceIn("field_declaration", 159);
		csParser.field_declaration_return retval = new csParser.field_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int field_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal553=null;
		csParser.variable_declarators_return variable_declarators552 = default(csParser.variable_declarators_return);

		object char_literal553_tree=null;

		try { DebugEnterRule(GrammarFileName, "field_declaration");
		DebugLocation(583, 28);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 159)) { return retval; }
			// cs.g:583:25: ( variable_declarators ';' )
			DebugEnterAlt(1);
			// cs.g:584:2: variable_declarators ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(584, 2);
			PushFollow(Follow._variable_declarators_in_field_declaration4421);
			variable_declarators552=variable_declarators();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_declarators552.Tree);
			DebugLocation(584, 25);
			char_literal553=(IToken)Match(input,SEMI,Follow._SEMI_in_field_declaration4425); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal553_tree = (object)adaptor.Create(char_literal553);
			adaptor.AddChild(root_0, char_literal553_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("field_declaration", 159);
			LeaveRule("field_declaration", 159);
			Leave_field_declaration();
			if (state.backtracking > 0) { Memoize(input, 159, field_declaration_StartIndex); }
		}
		DebugLocation(584, 28);
		} finally { DebugExitRule(GrammarFileName, "field_declaration"); }
		return retval;

	}
	// $ANTLR end "field_declaration"

	public class variable_declarators_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_variable_declarators();
	partial void Leave_variable_declarators();

	// $ANTLR start "variable_declarators"
	// cs.g:585:8: public variable_declarators : variable_declarator ( ',' variable_declarator )* ;
	[GrammarRule("variable_declarators")]
	public csParser.variable_declarators_return variable_declarators()
	{
		Enter_variable_declarators();
		EnterRule("variable_declarators", 160);
		TraceIn("variable_declarators", 160);
		csParser.variable_declarators_return retval = new csParser.variable_declarators_return();
		retval.Start = (IToken)input.LT(1);
		int variable_declarators_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal555=null;
		csParser.variable_declarator_return variable_declarator554 = default(csParser.variable_declarator_return);
		csParser.variable_declarator_return variable_declarator556 = default(csParser.variable_declarator_return);

		object char_literal555_tree=null;

		try { DebugEnterRule(GrammarFileName, "variable_declarators");
		DebugLocation(585, 50);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 160)) { return retval; }
			// cs.g:585:28: ( variable_declarator ( ',' variable_declarator )* )
			DebugEnterAlt(1);
			// cs.g:586:2: variable_declarator ( ',' variable_declarator )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(586, 2);
			PushFollow(Follow._variable_declarator_in_variable_declarators4435);
			variable_declarator554=variable_declarator();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_declarator554.Tree);
			DebugLocation(586, 22);
			// cs.g:586:22: ( ',' variable_declarator )*
			try { DebugEnterSubRule(151);
			while (true)
			{
				int alt151=2;
				try { DebugEnterDecision(151, decisionCanBacktrack[151]);
				int LA151_0 = input.LA(1);

				if ((LA151_0==91))
				{
					alt151=1;
				}


				} finally { DebugExitDecision(151); }
				switch ( alt151 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:586:23: ',' variable_declarator
					{
					DebugLocation(586, 23);
					char_literal555=(IToken)Match(input,91,Follow._91_in_variable_declarators4438); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal555_tree = (object)adaptor.Create(char_literal555);
					adaptor.AddChild(root_0, char_literal555_tree);
					}
					DebugLocation(586, 29);
					PushFollow(Follow._variable_declarator_in_variable_declarators4442);
					variable_declarator556=variable_declarator();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_declarator556.Tree);

					}
					break;

				default:
					goto loop151;
				}
			}

			loop151:
				;

			} finally { DebugExitSubRule(151); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("variable_declarators", 160);
			LeaveRule("variable_declarators", 160);
			Leave_variable_declarators();
			if (state.backtracking > 0) { Memoize(input, 160, variable_declarators_StartIndex); }
		}
		DebugLocation(586, 50);
		} finally { DebugExitRule(GrammarFileName, "variable_declarators"); }
		return retval;

	}
	// $ANTLR end "variable_declarators"

	public class variable_declarator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_variable_declarator();
	partial void Leave_variable_declarator();

	// $ANTLR start "variable_declarator"
	// cs.g:587:8: public variable_declarator : type_name ( '=' variable_initializer )? ;
	[GrammarRule("variable_declarator")]
	public csParser.variable_declarator_return variable_declarator()
	{
		Enter_variable_declarator();
		EnterRule("variable_declarator", 161);
		TraceIn("variable_declarator", 161);
		csParser.variable_declarator_return retval = new csParser.variable_declarator_return();
		retval.Start = (IToken)input.LT(1);
		int variable_declarator_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal558=null;
		csParser.type_name_return type_name557 = default(csParser.type_name_return);
		csParser.variable_initializer_return variable_initializer559 = default(csParser.variable_initializer_return);

		object char_literal558_tree=null;

		try { DebugEnterRule(GrammarFileName, "variable_declarator");
		DebugLocation(587, 41);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 161)) { return retval; }
			// cs.g:587:27: ( type_name ( '=' variable_initializer )? )
			DebugEnterAlt(1);
			// cs.g:588:2: type_name ( '=' variable_initializer )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(588, 2);
			PushFollow(Follow._type_name_in_variable_declarator4454);
			type_name557=type_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name557.Tree);
			DebugLocation(588, 12);
			// cs.g:588:12: ( '=' variable_initializer )?
			int alt152=2;
			try { DebugEnterSubRule(152);
			try { DebugEnterDecision(152, decisionCanBacktrack[152]);
			int LA152_0 = input.LA(1);

			if ((LA152_0==66))
			{
				alt152=1;
			}
			} finally { DebugExitDecision(152); }
			switch (alt152)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:588:13: '=' variable_initializer
				{
				DebugLocation(588, 13);
				char_literal558=(IToken)Match(input,66,Follow._66_in_variable_declarator4457); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal558_tree = (object)adaptor.Create(char_literal558);
				adaptor.AddChild(root_0, char_literal558_tree);
				}
				DebugLocation(588, 19);
				PushFollow(Follow._variable_initializer_in_variable_declarator4461);
				variable_initializer559=variable_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_initializer559.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(152); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("variable_declarator", 161);
			LeaveRule("variable_declarator", 161);
			Leave_variable_declarator();
			if (state.backtracking > 0) { Memoize(input, 161, variable_declarator_StartIndex); }
		}
		DebugLocation(588, 41);
		} finally { DebugExitRule(GrammarFileName, "variable_declarator"); }
		return retval;

	}
	// $ANTLR end "variable_declarator"

	public class method_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_method_declaration();
	partial void Leave_method_declaration();

	// $ANTLR start "method_declaration"
	// cs.g:591:8: public method_declaration : method_header method_body ;
	[GrammarRule("method_declaration")]
	public csParser.method_declaration_return method_declaration()
	{
		Enter_method_declaration();
		EnterRule("method_declaration", 162);
		TraceIn("method_declaration", 162);
		csParser.method_declaration_return retval = new csParser.method_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int method_declaration_StartIndex = input.Index;
		object root_0 = null;

		csParser.method_header_return method_header560 = default(csParser.method_header_return);
		csParser.method_body_return method_body561 = default(csParser.method_body_return);


		try { DebugEnterRule(GrammarFileName, "method_declaration");
		DebugLocation(591, 29);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 162)) { return retval; }
			// cs.g:591:26: ( method_header method_body )
			DebugEnterAlt(1);
			// cs.g:592:2: method_header method_body
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(592, 2);
			PushFollow(Follow._method_header_in_method_declaration4477);
			method_header560=method_header();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_header560.Tree);
			DebugLocation(592, 18);
			PushFollow(Follow._method_body_in_method_declaration4481);
			method_body561=method_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_body561.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("method_declaration", 162);
			LeaveRule("method_declaration", 162);
			Leave_method_declaration();
			if (state.backtracking > 0) { Memoize(input, 162, method_declaration_StartIndex); }
		}
		DebugLocation(592, 29);
		} finally { DebugExitRule(GrammarFileName, "method_declaration"); }
		return retval;

	}
	// $ANTLR end "method_declaration"

	public class method_header_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_method_header();
	partial void Leave_method_header();

	// $ANTLR start "method_header"
	// cs.g:593:8: public method_header : member_name '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ;
	[GrammarRule("method_header")]
	public csParser.method_header_return method_header()
	{
		Enter_method_header();
		EnterRule("method_header", 163);
		TraceIn("method_header", 163);
		csParser.method_header_return retval = new csParser.method_header_return();
		retval.Start = (IToken)input.LT(1);
		int method_header_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal563=null;
		IToken char_literal565=null;
		csParser.member_name_return member_name562 = default(csParser.member_name_return);
		csParser.formal_parameter_list_return formal_parameter_list564 = default(csParser.formal_parameter_list_return);
		csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses566 = default(csParser.type_parameter_constraints_clauses_return);

		object char_literal563_tree=null;
		object char_literal565_tree=null;

		try { DebugEnterRule(GrammarFileName, "method_header");
		DebugLocation(593, 87);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 163)) { return retval; }
			// cs.g:593:21: ( member_name '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? )
			DebugEnterAlt(1);
			// cs.g:594:2: member_name '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(594, 2);
			PushFollow(Follow._member_name_in_method_header4491);
			member_name562=member_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_name562.Tree);
			DebugLocation(594, 15);
			char_literal563=(IToken)Match(input,90,Follow._90_in_method_header4494); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal563_tree = (object)adaptor.Create(char_literal563);
			adaptor.AddChild(root_0, char_literal563_tree);
			}
			DebugLocation(594, 21);
			// cs.g:594:21: ( formal_parameter_list )?
			int alt153=2;
			try { DebugEnterSubRule(153);
			try { DebugEnterDecision(153, decisionCanBacktrack[153]);
			int LA153_0 = input.LA(1);

			if ((LA153_0==IDENTIFIER||(LA153_0>=ELIF && LA153_0<=UNDEF)||LA153_0==65||(LA153_0>=82 && LA153_0<=83)||LA153_0==88||(LA153_0>=93 && LA153_0<=94)||(LA153_0>=132 && LA153_0<=133)||(LA153_0>=135 && LA153_0<=148)||(LA153_0>=150 && LA153_0<=152)||LA153_0==154||(LA153_0>=156 && LA153_0<=168)||(LA153_0>=170 && LA153_0<=171)||(LA153_0>=177 && LA153_0<=178)||(LA153_0>=195 && LA153_0<=202)))
			{
				alt153=1;
			}
			} finally { DebugExitDecision(153); }
			switch (alt153)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:594:21: formal_parameter_list
				{
				DebugLocation(594, 21);
				PushFollow(Follow._formal_parameter_list_in_method_header4498);
				formal_parameter_list564=formal_parameter_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list564.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(153); }

			DebugLocation(594, 46);
			char_literal565=(IToken)Match(input,RPAREN,Follow._RPAREN_in_method_header4503); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal565_tree = (object)adaptor.Create(char_literal565);
			adaptor.AddChild(root_0, char_literal565_tree);
			}
			DebugLocation(594, 52);
			// cs.g:594:52: ( type_parameter_constraints_clauses )?
			int alt154=2;
			try { DebugEnterSubRule(154);
			try { DebugEnterDecision(154, decisionCanBacktrack[154]);
			int LA154_0 = input.LA(1);

			if ((LA154_0==145))
			{
				alt154=1;
			}
			} finally { DebugExitDecision(154); }
			switch (alt154)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:594:52: type_parameter_constraints_clauses
				{
				DebugLocation(594, 52);
				PushFollow(Follow._type_parameter_constraints_clauses_in_method_header4507);
				type_parameter_constraints_clauses566=type_parameter_constraints_clauses();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses566.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(154); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("method_header", 163);
			LeaveRule("method_header", 163);
			Leave_method_header();
			if (state.backtracking > 0) { Memoize(input, 163, method_header_StartIndex); }
		}
		DebugLocation(594, 87);
		} finally { DebugExitRule(GrammarFileName, "method_header"); }
		return retval;

	}
	// $ANTLR end "method_header"

	public class method_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_method_body();
	partial void Leave_method_body();

	// $ANTLR start "method_body"
	// cs.g:595:8: public method_body : block ;
	[GrammarRule("method_body")]
	public csParser.method_body_return method_body()
	{
		Enter_method_body();
		EnterRule("method_body", 164);
		TraceIn("method_body", 164);
		csParser.method_body_return retval = new csParser.method_body_return();
		retval.Start = (IToken)input.LT(1);
		int method_body_StartIndex = input.Index;
		object root_0 = null;

		csParser.block_return block567 = default(csParser.block_return);


		try { DebugEnterRule(GrammarFileName, "method_body");
		DebugLocation(595, 7);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 164)) { return retval; }
			// cs.g:595:19: ( block )
			DebugEnterAlt(1);
			// cs.g:596:2: block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(596, 2);
			PushFollow(Follow._block_in_method_body4518);
			block567=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block567.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("method_body", 164);
			LeaveRule("method_body", 164);
			Leave_method_body();
			if (state.backtracking > 0) { Memoize(input, 164, method_body_StartIndex); }
		}
		DebugLocation(596, 7);
		} finally { DebugExitRule(GrammarFileName, "method_body"); }
		return retval;

	}
	// $ANTLR end "method_body"

	public class member_name_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_member_name();
	partial void Leave_member_name();

	// $ANTLR start "member_name"
	// cs.g:597:8: public member_name : qid ;
	[GrammarRule("member_name")]
	public csParser.member_name_return member_name()
	{
		Enter_member_name();
		EnterRule("member_name", 165);
		TraceIn("member_name", 165);
		csParser.member_name_return retval = new csParser.member_name_return();
		retval.Start = (IToken)input.LT(1);
		int member_name_StartIndex = input.Index;
		object root_0 = null;

		csParser.qid_return qid568 = default(csParser.qid_return);


		try { DebugEnterRule(GrammarFileName, "member_name");
		DebugLocation(597, 5);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 165)) { return retval; }
			// cs.g:597:19: ( qid )
			DebugEnterAlt(1);
			// cs.g:598:2: qid
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(598, 2);
			PushFollow(Follow._qid_in_member_name4528);
			qid568=qid();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, qid568.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("member_name", 165);
			LeaveRule("member_name", 165);
			Leave_member_name();
			if (state.backtracking > 0) { Memoize(input, 165, member_name_StartIndex); }
		}
		DebugLocation(598, 5);
		} finally { DebugExitRule(GrammarFileName, "member_name"); }
		return retval;

	}
	// $ANTLR end "member_name"

	public class property_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_property_declaration();
	partial void Leave_property_declaration();

	// $ANTLR start "property_declaration"
	// cs.g:601:8: public property_declaration : member_name '{' accessor_declarations '}' ;
	[GrammarRule("property_declaration")]
	public csParser.property_declaration_return property_declaration()
	{
		Enter_property_declaration();
		EnterRule("property_declaration", 166);
		TraceIn("property_declaration", 166);
		csParser.property_declaration_return retval = new csParser.property_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int property_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal570=null;
		IToken char_literal572=null;
		csParser.member_name_return member_name569 = default(csParser.member_name_return);
		csParser.accessor_declarations_return accessor_declarations571 = default(csParser.accessor_declarations_return);

		object char_literal570_tree=null;
		object char_literal572_tree=null;

		try { DebugEnterRule(GrammarFileName, "property_declaration");
		DebugLocation(601, 49);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 166)) { return retval; }
			// cs.g:601:28: ( member_name '{' accessor_declarations '}' )
			DebugEnterAlt(1);
			// cs.g:602:2: member_name '{' accessor_declarations '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(602, 2);
			PushFollow(Follow._member_name_in_property_declaration4542);
			member_name569=member_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_name569.Tree);
			DebugLocation(602, 16);
			char_literal570=(IToken)Match(input,62,Follow._62_in_property_declaration4546); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal570_tree = (object)adaptor.Create(char_literal570);
			adaptor.AddChild(root_0, char_literal570_tree);
			}
			DebugLocation(602, 22);
			PushFollow(Follow._accessor_declarations_in_property_declaration4550);
			accessor_declarations571=accessor_declarations();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_declarations571.Tree);
			DebugLocation(602, 46);
			char_literal572=(IToken)Match(input,63,Follow._63_in_property_declaration4554); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal572_tree = (object)adaptor.Create(char_literal572);
			adaptor.AddChild(root_0, char_literal572_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("property_declaration", 166);
			LeaveRule("property_declaration", 166);
			Leave_property_declaration();
			if (state.backtracking > 0) { Memoize(input, 166, property_declaration_StartIndex); }
		}
		DebugLocation(602, 49);
		} finally { DebugExitRule(GrammarFileName, "property_declaration"); }
		return retval;

	}
	// $ANTLR end "property_declaration"

	public class accessor_declarations_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_accessor_declarations();
	partial void Leave_accessor_declarations();

	// $ANTLR start "accessor_declarations"
	// cs.g:603:8: public accessor_declarations : ( attributes )? ( get_accessor_declaration ( attributes )? ( set_accessor_declaration )? | set_accessor_declaration ( attributes )? ( get_accessor_declaration )? ) ;
	[GrammarRule("accessor_declarations")]
	public csParser.accessor_declarations_return accessor_declarations()
	{
		Enter_accessor_declarations();
		EnterRule("accessor_declarations", 167);
		TraceIn("accessor_declarations", 167);
		csParser.accessor_declarations_return retval = new csParser.accessor_declarations_return();
		retval.Start = (IToken)input.LT(1);
		int accessor_declarations_StartIndex = input.Index;
		object root_0 = null;

		csParser.attributes_return attributes573 = default(csParser.attributes_return);
		csParser.get_accessor_declaration_return get_accessor_declaration574 = default(csParser.get_accessor_declaration_return);
		csParser.attributes_return attributes575 = default(csParser.attributes_return);
		csParser.set_accessor_declaration_return set_accessor_declaration576 = default(csParser.set_accessor_declaration_return);
		csParser.set_accessor_declaration_return set_accessor_declaration577 = default(csParser.set_accessor_declaration_return);
		csParser.attributes_return attributes578 = default(csParser.attributes_return);
		csParser.get_accessor_declaration_return get_accessor_declaration579 = default(csParser.get_accessor_declaration_return);


		try { DebugEnterRule(GrammarFileName, "accessor_declarations");
		DebugLocation(603, 72);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 167)) { return retval; }
			// cs.g:603:29: ( ( attributes )? ( get_accessor_declaration ( attributes )? ( set_accessor_declaration )? | set_accessor_declaration ( attributes )? ( get_accessor_declaration )? ) )
			DebugEnterAlt(1);
			// cs.g:604:2: ( attributes )? ( get_accessor_declaration ( attributes )? ( set_accessor_declaration )? | set_accessor_declaration ( attributes )? ( get_accessor_declaration )? )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(604, 2);
			// cs.g:604:2: ( attributes )?
			int alt155=2;
			try { DebugEnterSubRule(155);
			try { DebugEnterDecision(155, decisionCanBacktrack[155]);
			int LA155_0 = input.LA(1);

			if ((LA155_0==88))
			{
				alt155=1;
			}
			} finally { DebugExitDecision(155); }
			switch (alt155)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:604:2: attributes
				{
				DebugLocation(604, 2);
				PushFollow(Follow._attributes_in_accessor_declarations4564);
				attributes573=attributes();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes573.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(155); }

			DebugLocation(605, 3);
			// cs.g:605:3: ( get_accessor_declaration ( attributes )? ( set_accessor_declaration )? | set_accessor_declaration ( attributes )? ( get_accessor_declaration )? )
			int alt160=2;
			try { DebugEnterSubRule(160);
			try { DebugEnterDecision(160, decisionCanBacktrack[160]);
			switch (input.LA(1))
			{
			case 69:
			case 70:
			case 71:
			case 72:
				{
				int LA160_1 = input.LA(2);

				if ((LA160_1==156))
				{
					alt160=1;
				}
				else if ((LA160_1==157))
				{
					alt160=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 160, 1, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case 156:
				{
				alt160=1;
				}
				break;
			case 157:
				{
				alt160=2;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 160, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(160); }
			switch (alt160)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:605:4: get_accessor_declaration ( attributes )? ( set_accessor_declaration )?
				{
				DebugLocation(605, 4);
				PushFollow(Follow._get_accessor_declaration_in_accessor_declarations4570);
				get_accessor_declaration574=get_accessor_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, get_accessor_declaration574.Tree);
				DebugLocation(605, 31);
				// cs.g:605:31: ( attributes )?
				int alt156=2;
				try { DebugEnterSubRule(156);
				try { DebugEnterDecision(156, decisionCanBacktrack[156]);
				int LA156_0 = input.LA(1);

				if ((LA156_0==88))
				{
					alt156=1;
				}
				} finally { DebugExitDecision(156); }
				switch (alt156)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:605:31: attributes
					{
					DebugLocation(605, 31);
					PushFollow(Follow._attributes_in_accessor_declarations4574);
					attributes575=attributes();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes575.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(156); }

				DebugLocation(605, 45);
				// cs.g:605:45: ( set_accessor_declaration )?
				int alt157=2;
				try { DebugEnterSubRule(157);
				try { DebugEnterDecision(157, decisionCanBacktrack[157]);
				int LA157_0 = input.LA(1);

				if (((LA157_0>=69 && LA157_0<=72)||LA157_0==157))
				{
					alt157=1;
				}
				} finally { DebugExitDecision(157); }
				switch (alt157)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:605:45: set_accessor_declaration
					{
					DebugLocation(605, 45);
					PushFollow(Follow._set_accessor_declaration_in_accessor_declarations4579);
					set_accessor_declaration576=set_accessor_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, set_accessor_declaration576.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(157); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:606:5: set_accessor_declaration ( attributes )? ( get_accessor_declaration )?
				{
				DebugLocation(606, 5);
				PushFollow(Follow._set_accessor_declaration_in_accessor_declarations4586);
				set_accessor_declaration577=set_accessor_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, set_accessor_declaration577.Tree);
				DebugLocation(606, 32);
				// cs.g:606:32: ( attributes )?
				int alt158=2;
				try { DebugEnterSubRule(158);
				try { DebugEnterDecision(158, decisionCanBacktrack[158]);
				int LA158_0 = input.LA(1);

				if ((LA158_0==88))
				{
					alt158=1;
				}
				} finally { DebugExitDecision(158); }
				switch (alt158)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:606:32: attributes
					{
					DebugLocation(606, 32);
					PushFollow(Follow._attributes_in_accessor_declarations4590);
					attributes578=attributes();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes578.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(158); }

				DebugLocation(606, 46);
				// cs.g:606:46: ( get_accessor_declaration )?
				int alt159=2;
				try { DebugEnterSubRule(159);
				try { DebugEnterDecision(159, decisionCanBacktrack[159]);
				int LA159_0 = input.LA(1);

				if (((LA159_0>=69 && LA159_0<=72)||LA159_0==156))
				{
					alt159=1;
				}
				} finally { DebugExitDecision(159); }
				switch (alt159)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:606:46: get_accessor_declaration
					{
					DebugLocation(606, 46);
					PushFollow(Follow._get_accessor_declaration_in_accessor_declarations4595);
					get_accessor_declaration579=get_accessor_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, get_accessor_declaration579.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(159); }


				}
				break;

			}
			} finally { DebugExitSubRule(160); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("accessor_declarations", 167);
			LeaveRule("accessor_declarations", 167);
			Leave_accessor_declarations();
			if (state.backtracking > 0) { Memoize(input, 167, accessor_declarations_StartIndex); }
		}
		DebugLocation(606, 72);
		} finally { DebugExitRule(GrammarFileName, "accessor_declarations"); }
		return retval;

	}
	// $ANTLR end "accessor_declarations"

	public class get_accessor_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_get_accessor_declaration();
	partial void Leave_get_accessor_declaration();

	// $ANTLR start "get_accessor_declaration"
	// cs.g:607:8: public get_accessor_declaration : ( accessor_modifier )? 'get' accessor_body ;
	[GrammarRule("get_accessor_declaration")]
	public csParser.get_accessor_declaration_return get_accessor_declaration()
	{
		Enter_get_accessor_declaration();
		EnterRule("get_accessor_declaration", 168);
		TraceIn("get_accessor_declaration", 168);
		csParser.get_accessor_declaration_return retval = new csParser.get_accessor_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int get_accessor_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal581=null;
		csParser.accessor_modifier_return accessor_modifier580 = default(csParser.accessor_modifier_return);
		csParser.accessor_body_return accessor_body582 = default(csParser.accessor_body_return);

		object string_literal581_tree=null;

		try { DebugEnterRule(GrammarFileName, "get_accessor_declaration");
		DebugLocation(607, 44);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 168)) { return retval; }
			// cs.g:607:32: ( ( accessor_modifier )? 'get' accessor_body )
			DebugEnterAlt(1);
			// cs.g:608:2: ( accessor_modifier )? 'get' accessor_body
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(608, 2);
			// cs.g:608:2: ( accessor_modifier )?
			int alt161=2;
			try { DebugEnterSubRule(161);
			try { DebugEnterDecision(161, decisionCanBacktrack[161]);
			int LA161_0 = input.LA(1);

			if (((LA161_0>=69 && LA161_0<=72)))
			{
				alt161=1;
			}
			} finally { DebugExitDecision(161); }
			switch (alt161)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:608:2: accessor_modifier
				{
				DebugLocation(608, 2);
				PushFollow(Follow._accessor_modifier_in_get_accessor_declaration4607);
				accessor_modifier580=accessor_modifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_modifier580.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(161); }

			DebugLocation(608, 23);
			string_literal581=(IToken)Match(input,156,Follow._156_in_get_accessor_declaration4612); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal581_tree = (object)adaptor.Create(string_literal581);
			adaptor.AddChild(root_0, string_literal581_tree);
			}
			DebugLocation(608, 31);
			PushFollow(Follow._accessor_body_in_get_accessor_declaration4616);
			accessor_body582=accessor_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_body582.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("get_accessor_declaration", 168);
			LeaveRule("get_accessor_declaration", 168);
			Leave_get_accessor_declaration();
			if (state.backtracking > 0) { Memoize(input, 168, get_accessor_declaration_StartIndex); }
		}
		DebugLocation(608, 44);
		} finally { DebugExitRule(GrammarFileName, "get_accessor_declaration"); }
		return retval;

	}
	// $ANTLR end "get_accessor_declaration"

	public class set_accessor_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_set_accessor_declaration();
	partial void Leave_set_accessor_declaration();

	// $ANTLR start "set_accessor_declaration"
	// cs.g:609:8: public set_accessor_declaration : ( accessor_modifier )? 'set' accessor_body ;
	[GrammarRule("set_accessor_declaration")]
	public csParser.set_accessor_declaration_return set_accessor_declaration()
	{
		Enter_set_accessor_declaration();
		EnterRule("set_accessor_declaration", 169);
		TraceIn("set_accessor_declaration", 169);
		csParser.set_accessor_declaration_return retval = new csParser.set_accessor_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int set_accessor_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal584=null;
		csParser.accessor_modifier_return accessor_modifier583 = default(csParser.accessor_modifier_return);
		csParser.accessor_body_return accessor_body585 = default(csParser.accessor_body_return);

		object string_literal584_tree=null;

		try { DebugEnterRule(GrammarFileName, "set_accessor_declaration");
		DebugLocation(609, 44);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 169)) { return retval; }
			// cs.g:609:32: ( ( accessor_modifier )? 'set' accessor_body )
			DebugEnterAlt(1);
			// cs.g:610:2: ( accessor_modifier )? 'set' accessor_body
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(610, 2);
			// cs.g:610:2: ( accessor_modifier )?
			int alt162=2;
			try { DebugEnterSubRule(162);
			try { DebugEnterDecision(162, decisionCanBacktrack[162]);
			int LA162_0 = input.LA(1);

			if (((LA162_0>=69 && LA162_0<=72)))
			{
				alt162=1;
			}
			} finally { DebugExitDecision(162); }
			switch (alt162)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:610:2: accessor_modifier
				{
				DebugLocation(610, 2);
				PushFollow(Follow._accessor_modifier_in_set_accessor_declaration4626);
				accessor_modifier583=accessor_modifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_modifier583.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(162); }

			DebugLocation(610, 23);
			string_literal584=(IToken)Match(input,157,Follow._157_in_set_accessor_declaration4631); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal584_tree = (object)adaptor.Create(string_literal584);
			adaptor.AddChild(root_0, string_literal584_tree);
			}
			DebugLocation(610, 31);
			PushFollow(Follow._accessor_body_in_set_accessor_declaration4635);
			accessor_body585=accessor_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_body585.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("set_accessor_declaration", 169);
			LeaveRule("set_accessor_declaration", 169);
			Leave_set_accessor_declaration();
			if (state.backtracking > 0) { Memoize(input, 169, set_accessor_declaration_StartIndex); }
		}
		DebugLocation(610, 44);
		} finally { DebugExitRule(GrammarFileName, "set_accessor_declaration"); }
		return retval;

	}
	// $ANTLR end "set_accessor_declaration"

	public class accessor_modifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_accessor_modifier();
	partial void Leave_accessor_modifier();

	// $ANTLR start "accessor_modifier"
	// cs.g:611:8: public accessor_modifier : ( 'public' | 'protected' | 'private' | 'internal' );
	[GrammarRule("accessor_modifier")]
	public csParser.accessor_modifier_return accessor_modifier()
	{
		Enter_accessor_modifier();
		EnterRule("accessor_modifier", 170);
		TraceIn("accessor_modifier", 170);
		csParser.accessor_modifier_return retval = new csParser.accessor_modifier_return();
		retval.Start = (IToken)input.LT(1);
		int accessor_modifier_StartIndex = input.Index;
		object root_0 = null;

		IToken set586=null;

		object set586_tree=null;

		try { DebugEnterRule(GrammarFileName, "accessor_modifier");
		DebugLocation(611, 49);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 170)) { return retval; }
			// cs.g:611:25: ( 'public' | 'protected' | 'private' | 'internal' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(611, 25);
			set586=(IToken)input.LT(1);
			if ((input.LA(1)>=69 && input.LA(1)<=72))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set586));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("accessor_modifier", 170);
			LeaveRule("accessor_modifier", 170);
			Leave_accessor_modifier();
			if (state.backtracking > 0) { Memoize(input, 170, accessor_modifier_StartIndex); }
		}
		DebugLocation(612, 49);
		} finally { DebugExitRule(GrammarFileName, "accessor_modifier"); }
		return retval;

	}
	// $ANTLR end "accessor_modifier"

	public class accessor_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_accessor_body();
	partial void Leave_accessor_body();

	// $ANTLR start "accessor_body"
	// cs.g:613:8: public accessor_body : block ;
	[GrammarRule("accessor_body")]
	public csParser.accessor_body_return accessor_body()
	{
		Enter_accessor_body();
		EnterRule("accessor_body", 171);
		TraceIn("accessor_body", 171);
		csParser.accessor_body_return retval = new csParser.accessor_body_return();
		retval.Start = (IToken)input.LT(1);
		int accessor_body_StartIndex = input.Index;
		object root_0 = null;

		csParser.block_return block587 = default(csParser.block_return);


		try { DebugEnterRule(GrammarFileName, "accessor_body");
		DebugLocation(613, 7);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 171)) { return retval; }
			// cs.g:613:21: ( block )
			DebugEnterAlt(1);
			// cs.g:614:2: block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(614, 2);
			PushFollow(Follow._block_in_accessor_body4667);
			block587=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block587.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("accessor_body", 171);
			LeaveRule("accessor_body", 171);
			Leave_accessor_body();
			if (state.backtracking > 0) { Memoize(input, 171, accessor_body_StartIndex); }
		}
		DebugLocation(614, 7);
		} finally { DebugExitRule(GrammarFileName, "accessor_body"); }
		return retval;

	}
	// $ANTLR end "accessor_body"

	public class event_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_event_declaration();
	partial void Leave_event_declaration();

	// $ANTLR start "event_declaration"
	// cs.g:617:8: public event_declaration : 'event' type ( ( member_name '{' )=> member_name '{' event_accessor_declarations '}' | variable_declarators ';' ) ;
	[GrammarRule("event_declaration")]
	public csParser.event_declaration_return event_declaration()
	{
		Enter_event_declaration();
		EnterRule("event_declaration", 172);
		TraceIn("event_declaration", 172);
		csParser.event_declaration_return retval = new csParser.event_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int event_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal588=null;
		IToken char_literal591=null;
		IToken char_literal593=null;
		IToken char_literal595=null;
		csParser.type_return type589 = default(csParser.type_return);
		csParser.member_name_return member_name590 = default(csParser.member_name_return);
		csParser.event_accessor_declarations_return event_accessor_declarations592 = default(csParser.event_accessor_declarations_return);
		csParser.variable_declarators_return variable_declarators594 = default(csParser.variable_declarators_return);

		object string_literal588_tree=null;
		object char_literal591_tree=null;
		object char_literal593_tree=null;
		object char_literal595_tree=null;

		try { DebugEnterRule(GrammarFileName, "event_declaration");
		DebugLocation(617, 2);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 172)) { return retval; }
			// cs.g:617:25: ( 'event' type ( ( member_name '{' )=> member_name '{' event_accessor_declarations '}' | variable_declarators ';' ) )
			DebugEnterAlt(1);
			// cs.g:618:2: 'event' type ( ( member_name '{' )=> member_name '{' event_accessor_declarations '}' | variable_declarators ';' )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(618, 2);
			string_literal588=(IToken)Match(input,149,Follow._149_in_event_declaration4679); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal588_tree = (object)adaptor.Create(string_literal588);
			adaptor.AddChild(root_0, string_literal588_tree);
			}
			DebugLocation(618, 12);
			PushFollow(Follow._type_in_event_declaration4683);
			type589=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type589.Tree);
			DebugLocation(619, 3);
			// cs.g:619:3: ( ( member_name '{' )=> member_name '{' event_accessor_declarations '}' | variable_declarators ';' )
			int alt163=2;
			try { DebugEnterSubRule(163);
			try { DebugEnterDecision(163, decisionCanBacktrack[163]);
			int LA163_0 = input.LA(1);

			if (((LA163_0>=160 && LA163_0<=168)||(LA163_0>=196 && LA163_0<=201)) && (EvaluatePredicate(synpred25_cs_fragment)))
			{
				alt163=1;
			}
			else if ((LA163_0==IDENTIFIER))
			{
				int LA163_2 = input.LA(2);

				if ((EvaluatePredicate(synpred25_cs_fragment)))
				{
					alt163=1;
				}
				else if ((true))
				{
					alt163=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 163, 2, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}
			else if (((LA163_0>=ELIF && LA163_0<=UNDEF)||LA163_0==65||(LA163_0>=132 && LA163_0<=133)||(LA163_0>=135 && LA163_0<=148)||(LA163_0>=150 && LA163_0<=152)||LA163_0==154||(LA163_0>=156 && LA163_0<=159)||LA163_0==170||(LA163_0>=177 && LA163_0<=178)||LA163_0==195||LA163_0==202))
			{
				int LA163_3 = input.LA(2);

				if ((EvaluatePredicate(synpred25_cs_fragment)))
				{
					alt163=1;
				}
				else if ((true))
				{
					alt163=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 163, 3, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}
			else if (((LA163_0>=Real_literal && LA163_0<=NULL)) && (EvaluatePredicate(synpred25_cs_fragment)))
			{
				alt163=1;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 163, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(163); }
			switch (alt163)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:619:4: ( member_name '{' )=> member_name '{' event_accessor_declarations '}'
				{
				DebugLocation(619, 27);
				PushFollow(Follow._member_name_in_event_declaration4698);
				member_name590=member_name();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_name590.Tree);
				DebugLocation(619, 41);
				char_literal591=(IToken)Match(input,62,Follow._62_in_event_declaration4702); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal591_tree = (object)adaptor.Create(char_literal591);
				adaptor.AddChild(root_0, char_literal591_tree);
				}
				DebugLocation(619, 47);
				PushFollow(Follow._event_accessor_declarations_in_event_declaration4706);
				event_accessor_declarations592=event_accessor_declarations();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, event_accessor_declarations592.Tree);
				DebugLocation(619, 77);
				char_literal593=(IToken)Match(input,63,Follow._63_in_event_declaration4710); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal593_tree = (object)adaptor.Create(char_literal593);
				adaptor.AddChild(root_0, char_literal593_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:620:5: variable_declarators ';'
				{
				DebugLocation(620, 5);
				PushFollow(Follow._variable_declarators_in_event_declaration4716);
				variable_declarators594=variable_declarators();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_declarators594.Tree);
				DebugLocation(620, 28);
				char_literal595=(IToken)Match(input,SEMI,Follow._SEMI_in_event_declaration4720); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal595_tree = (object)adaptor.Create(char_literal595);
				adaptor.AddChild(root_0, char_literal595_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(163); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("event_declaration", 172);
			LeaveRule("event_declaration", 172);
			Leave_event_declaration();
			if (state.backtracking > 0) { Memoize(input, 172, event_declaration_StartIndex); }
		}
		DebugLocation(621, 2);
		} finally { DebugExitRule(GrammarFileName, "event_declaration"); }
		return retval;

	}
	// $ANTLR end "event_declaration"

	public class event_modifiers_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_event_modifiers();
	partial void Leave_event_modifiers();

	// $ANTLR start "event_modifiers"
	// cs.g:622:8: public event_modifiers : ( modifier )+ ;
	[GrammarRule("event_modifiers")]
	public csParser.event_modifiers_return event_modifiers()
	{
		Enter_event_modifiers();
		EnterRule("event_modifiers", 173);
		TraceIn("event_modifiers", 173);
		csParser.event_modifiers_return retval = new csParser.event_modifiers_return();
		retval.Start = (IToken)input.LT(1);
		int event_modifiers_StartIndex = input.Index;
		object root_0 = null;

		csParser.modifier_return modifier596 = default(csParser.modifier_return);


		try { DebugEnterRule(GrammarFileName, "event_modifiers");
		DebugLocation(622, 11);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 173)) { return retval; }
			// cs.g:622:23: ( ( modifier )+ )
			DebugEnterAlt(1);
			// cs.g:623:2: ( modifier )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(623, 2);
			// cs.g:623:2: ( modifier )+
			int cnt164=0;
			try { DebugEnterSubRule(164);
			while (true)
			{
				int alt164=2;
				try { DebugEnterDecision(164, decisionCanBacktrack[164]);
				int LA164_0 = input.LA(1);

				if ((LA164_0==64||(LA164_0>=68 && LA164_0<=80)))
				{
					alt164=1;
				}


				} finally { DebugExitDecision(164); }
				switch (alt164)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:623:2: modifier
					{
					DebugLocation(623, 2);
					PushFollow(Follow._modifier_in_event_modifiers4734);
					modifier596=modifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifier596.Tree);

					}
					break;

				default:
					if (cnt164 >= 1)
						goto loop164;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee164 = new EarlyExitException( 164, input );
					DebugRecognitionException(eee164);
					throw eee164;
				}
				cnt164++;
			}
			loop164:
				;

			} finally { DebugExitSubRule(164); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("event_modifiers", 173);
			LeaveRule("event_modifiers", 173);
			Leave_event_modifiers();
			if (state.backtracking > 0) { Memoize(input, 173, event_modifiers_StartIndex); }
		}
		DebugLocation(623, 11);
		} finally { DebugExitRule(GrammarFileName, "event_modifiers"); }
		return retval;

	}
	// $ANTLR end "event_modifiers"

	public class event_accessor_declarations_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_event_accessor_declarations();
	partial void Leave_event_accessor_declarations();

	// $ANTLR start "event_accessor_declarations"
	// cs.g:624:8: public event_accessor_declarations : ( attributes )? ( ( add_accessor_declaration ( attributes )? remove_accessor_declaration ) | ( remove_accessor_declaration ( attributes )? add_accessor_declaration ) ) ;
	[GrammarRule("event_accessor_declarations")]
	public csParser.event_accessor_declarations_return event_accessor_declarations()
	{
		Enter_event_accessor_declarations();
		EnterRule("event_accessor_declarations", 174);
		TraceIn("event_accessor_declarations", 174);
		csParser.event_accessor_declarations_return retval = new csParser.event_accessor_declarations_return();
		retval.Start = (IToken)input.LT(1);
		int event_accessor_declarations_StartIndex = input.Index;
		object root_0 = null;

		csParser.attributes_return attributes597 = default(csParser.attributes_return);
		csParser.add_accessor_declaration_return add_accessor_declaration598 = default(csParser.add_accessor_declaration_return);
		csParser.attributes_return attributes599 = default(csParser.attributes_return);
		csParser.remove_accessor_declaration_return remove_accessor_declaration600 = default(csParser.remove_accessor_declaration_return);
		csParser.remove_accessor_declaration_return remove_accessor_declaration601 = default(csParser.remove_accessor_declaration_return);
		csParser.attributes_return attributes602 = default(csParser.attributes_return);
		csParser.add_accessor_declaration_return add_accessor_declaration603 = default(csParser.add_accessor_declaration_return);


		try { DebugEnterRule(GrammarFileName, "event_accessor_declarations");
		DebugLocation(624, 89);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 174)) { return retval; }
			// cs.g:624:35: ( ( attributes )? ( ( add_accessor_declaration ( attributes )? remove_accessor_declaration ) | ( remove_accessor_declaration ( attributes )? add_accessor_declaration ) ) )
			DebugEnterAlt(1);
			// cs.g:625:2: ( attributes )? ( ( add_accessor_declaration ( attributes )? remove_accessor_declaration ) | ( remove_accessor_declaration ( attributes )? add_accessor_declaration ) )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(625, 2);
			// cs.g:625:2: ( attributes )?
			int alt165=2;
			try { DebugEnterSubRule(165);
			try { DebugEnterDecision(165, decisionCanBacktrack[165]);
			int LA165_0 = input.LA(1);

			if ((LA165_0==88))
			{
				alt165=1;
			}
			} finally { DebugExitDecision(165); }
			switch (alt165)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:625:2: attributes
				{
				DebugLocation(625, 2);
				PushFollow(Follow._attributes_in_event_accessor_declarations4745);
				attributes597=attributes();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes597.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(165); }

			DebugLocation(625, 16);
			// cs.g:625:16: ( ( add_accessor_declaration ( attributes )? remove_accessor_declaration ) | ( remove_accessor_declaration ( attributes )? add_accessor_declaration ) )
			int alt168=2;
			try { DebugEnterSubRule(168);
			try { DebugEnterDecision(168, decisionCanBacktrack[168]);
			int LA168_0 = input.LA(1);

			if ((LA168_0==158))
			{
				alt168=1;
			}
			else if ((LA168_0==159))
			{
				alt168=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 168, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(168); }
			switch (alt168)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:625:17: ( add_accessor_declaration ( attributes )? remove_accessor_declaration )
				{
				DebugLocation(625, 17);
				// cs.g:625:17: ( add_accessor_declaration ( attributes )? remove_accessor_declaration )
				DebugEnterAlt(1);
				// cs.g:625:18: add_accessor_declaration ( attributes )? remove_accessor_declaration
				{
				DebugLocation(625, 18);
				PushFollow(Follow._add_accessor_declaration_in_event_accessor_declarations4752);
				add_accessor_declaration598=add_accessor_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, add_accessor_declaration598.Tree);
				DebugLocation(625, 45);
				// cs.g:625:45: ( attributes )?
				int alt166=2;
				try { DebugEnterSubRule(166);
				try { DebugEnterDecision(166, decisionCanBacktrack[166]);
				int LA166_0 = input.LA(1);

				if ((LA166_0==88))
				{
					alt166=1;
				}
				} finally { DebugExitDecision(166); }
				switch (alt166)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:625:45: attributes
					{
					DebugLocation(625, 45);
					PushFollow(Follow._attributes_in_event_accessor_declarations4756);
					attributes599=attributes();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes599.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(166); }

				DebugLocation(625, 59);
				PushFollow(Follow._remove_accessor_declaration_in_event_accessor_declarations4761);
				remove_accessor_declaration600=remove_accessor_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, remove_accessor_declaration600.Tree);

				}


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:626:18: ( remove_accessor_declaration ( attributes )? add_accessor_declaration )
				{
				DebugLocation(626, 18);
				// cs.g:626:18: ( remove_accessor_declaration ( attributes )? add_accessor_declaration )
				DebugEnterAlt(1);
				// cs.g:626:19: remove_accessor_declaration ( attributes )? add_accessor_declaration
				{
				DebugLocation(626, 19);
				PushFollow(Follow._remove_accessor_declaration_in_event_accessor_declarations4782);
				remove_accessor_declaration601=remove_accessor_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, remove_accessor_declaration601.Tree);
				DebugLocation(626, 49);
				// cs.g:626:49: ( attributes )?
				int alt167=2;
				try { DebugEnterSubRule(167);
				try { DebugEnterDecision(167, decisionCanBacktrack[167]);
				int LA167_0 = input.LA(1);

				if ((LA167_0==88))
				{
					alt167=1;
				}
				} finally { DebugExitDecision(167); }
				switch (alt167)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:626:49: attributes
					{
					DebugLocation(626, 49);
					PushFollow(Follow._attributes_in_event_accessor_declarations4786);
					attributes602=attributes();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes602.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(167); }

				DebugLocation(626, 63);
				PushFollow(Follow._add_accessor_declaration_in_event_accessor_declarations4791);
				add_accessor_declaration603=add_accessor_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, add_accessor_declaration603.Tree);

				}


				}
				break;

			}
			} finally { DebugExitSubRule(168); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("event_accessor_declarations", 174);
			LeaveRule("event_accessor_declarations", 174);
			Leave_event_accessor_declarations();
			if (state.backtracking > 0) { Memoize(input, 174, event_accessor_declarations_StartIndex); }
		}
		DebugLocation(626, 89);
		} finally { DebugExitRule(GrammarFileName, "event_accessor_declarations"); }
		return retval;

	}
	// $ANTLR end "event_accessor_declarations"

	public class add_accessor_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_add_accessor_declaration();
	partial void Leave_add_accessor_declaration();

	// $ANTLR start "add_accessor_declaration"
	// cs.g:627:8: public add_accessor_declaration : 'add' block ;
	[GrammarRule("add_accessor_declaration")]
	public csParser.add_accessor_declaration_return add_accessor_declaration()
	{
		Enter_add_accessor_declaration();
		EnterRule("add_accessor_declaration", 175);
		TraceIn("add_accessor_declaration", 175);
		csParser.add_accessor_declaration_return retval = new csParser.add_accessor_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int add_accessor_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal604=null;
		csParser.block_return block605 = default(csParser.block_return);

		object string_literal604_tree=null;

		try { DebugEnterRule(GrammarFileName, "add_accessor_declaration");
		DebugLocation(627, 15);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 175)) { return retval; }
			// cs.g:627:32: ( 'add' block )
			DebugEnterAlt(1);
			// cs.g:628:2: 'add' block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(628, 2);
			string_literal604=(IToken)Match(input,158,Follow._158_in_add_accessor_declaration4803); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal604_tree = (object)adaptor.Create(string_literal604);
			adaptor.AddChild(root_0, string_literal604_tree);
			}
			DebugLocation(628, 10);
			PushFollow(Follow._block_in_add_accessor_declaration4807);
			block605=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block605.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("add_accessor_declaration", 175);
			LeaveRule("add_accessor_declaration", 175);
			Leave_add_accessor_declaration();
			if (state.backtracking > 0) { Memoize(input, 175, add_accessor_declaration_StartIndex); }
		}
		DebugLocation(628, 15);
		} finally { DebugExitRule(GrammarFileName, "add_accessor_declaration"); }
		return retval;

	}
	// $ANTLR end "add_accessor_declaration"

	public class remove_accessor_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_remove_accessor_declaration();
	partial void Leave_remove_accessor_declaration();

	// $ANTLR start "remove_accessor_declaration"
	// cs.g:629:8: public remove_accessor_declaration : 'remove' block ;
	[GrammarRule("remove_accessor_declaration")]
	public csParser.remove_accessor_declaration_return remove_accessor_declaration()
	{
		Enter_remove_accessor_declaration();
		EnterRule("remove_accessor_declaration", 176);
		TraceIn("remove_accessor_declaration", 176);
		csParser.remove_accessor_declaration_return retval = new csParser.remove_accessor_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int remove_accessor_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal606=null;
		csParser.block_return block607 = default(csParser.block_return);

		object string_literal606_tree=null;

		try { DebugEnterRule(GrammarFileName, "remove_accessor_declaration");
		DebugLocation(629, 18);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 176)) { return retval; }
			// cs.g:629:35: ( 'remove' block )
			DebugEnterAlt(1);
			// cs.g:630:2: 'remove' block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(630, 2);
			string_literal606=(IToken)Match(input,159,Follow._159_in_remove_accessor_declaration4817); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal606_tree = (object)adaptor.Create(string_literal606);
			adaptor.AddChild(root_0, string_literal606_tree);
			}
			DebugLocation(630, 13);
			PushFollow(Follow._block_in_remove_accessor_declaration4821);
			block607=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block607.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("remove_accessor_declaration", 176);
			LeaveRule("remove_accessor_declaration", 176);
			Leave_remove_accessor_declaration();
			if (state.backtracking > 0) { Memoize(input, 176, remove_accessor_declaration_StartIndex); }
		}
		DebugLocation(630, 18);
		} finally { DebugExitRule(GrammarFileName, "remove_accessor_declaration"); }
		return retval;

	}
	// $ANTLR end "remove_accessor_declaration"

	public class enum_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_enum_declaration();
	partial void Leave_enum_declaration();

	// $ANTLR start "enum_declaration"
	// cs.g:635:8: public enum_declaration : 'enum' identifier ( enum_base )? enum_body ( ';' )? ;
	[GrammarRule("enum_declaration")]
	public csParser.enum_declaration_return enum_declaration()
	{
		Enter_enum_declaration();
		EnterRule("enum_declaration", 177);
		TraceIn("enum_declaration", 177);
		csParser.enum_declaration_return retval = new csParser.enum_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int enum_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal608=null;
		IToken char_literal612=null;
		csParser.identifier_return identifier609 = default(csParser.identifier_return);
		csParser.enum_base_return enum_base610 = default(csParser.enum_base_return);
		csParser.enum_body_return enum_body611 = default(csParser.enum_body_return);

		object string_literal608_tree=null;
		object char_literal612_tree=null;

		try { DebugEnterRule(GrammarFileName, "enum_declaration");
		DebugLocation(635, 53);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 177)) { return retval; }
			// cs.g:635:24: ( 'enum' identifier ( enum_base )? enum_body ( ';' )? )
			DebugEnterAlt(1);
			// cs.g:636:2: 'enum' identifier ( enum_base )? enum_body ( ';' )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(636, 2);
			string_literal608=(IToken)Match(input,ENUM,Follow._ENUM_in_enum_declaration4835); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal608_tree = (object)adaptor.Create(string_literal608);
			adaptor.AddChild(root_0, string_literal608_tree);
			}
			DebugLocation(636, 11);
			PushFollow(Follow._identifier_in_enum_declaration4839);
			identifier609=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier609.Tree);
			DebugLocation(636, 24);
			// cs.g:636:24: ( enum_base )?
			int alt169=2;
			try { DebugEnterSubRule(169);
			try { DebugEnterDecision(169, decisionCanBacktrack[169]);
			int LA169_0 = input.LA(1);

			if ((LA169_0==92))
			{
				alt169=1;
			}
			} finally { DebugExitDecision(169); }
			switch (alt169)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:636:24: enum_base
				{
				DebugLocation(636, 24);
				PushFollow(Follow._enum_base_in_enum_declaration4843);
				enum_base610=enum_base();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_base610.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(169); }

			DebugLocation(636, 37);
			PushFollow(Follow._enum_body_in_enum_declaration4848);
			enum_body611=enum_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_body611.Tree);
			DebugLocation(636, 49);
			// cs.g:636:49: ( ';' )?
			int alt170=2;
			try { DebugEnterSubRule(170);
			try { DebugEnterDecision(170, decisionCanBacktrack[170]);
			int LA170_0 = input.LA(1);

			if ((LA170_0==SEMI))
			{
				alt170=1;
			}
			} finally { DebugExitDecision(170); }
			switch (alt170)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:636:49: ';'
				{
				DebugLocation(636, 49);
				char_literal612=(IToken)Match(input,SEMI,Follow._SEMI_in_enum_declaration4852); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal612_tree = (object)adaptor.Create(char_literal612);
				adaptor.AddChild(root_0, char_literal612_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(170); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("enum_declaration", 177);
			LeaveRule("enum_declaration", 177);
			Leave_enum_declaration();
			if (state.backtracking > 0) { Memoize(input, 177, enum_declaration_StartIndex); }
		}
		DebugLocation(636, 53);
		} finally { DebugExitRule(GrammarFileName, "enum_declaration"); }
		return retval;

	}
	// $ANTLR end "enum_declaration"

	public class enum_base_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_enum_base();
	partial void Leave_enum_base();

	// $ANTLR start "enum_base"
	// cs.g:637:8: public enum_base : ':' integral_type ;
	[GrammarRule("enum_base")]
	public csParser.enum_base_return enum_base()
	{
		Enter_enum_base();
		EnterRule("enum_base", 178);
		TraceIn("enum_base", 178);
		csParser.enum_base_return retval = new csParser.enum_base_return();
		retval.Start = (IToken)input.LT(1);
		int enum_base_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal613=null;
		csParser.integral_type_return integral_type614 = default(csParser.integral_type_return);

		object char_literal613_tree=null;

		try { DebugEnterRule(GrammarFileName, "enum_base");
		DebugLocation(637, 21);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 178)) { return retval; }
			// cs.g:637:17: ( ':' integral_type )
			DebugEnterAlt(1);
			// cs.g:638:2: ':' integral_type
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(638, 2);
			char_literal613=(IToken)Match(input,92,Follow._92_in_enum_base4863); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal613_tree = (object)adaptor.Create(char_literal613);
			adaptor.AddChild(root_0, char_literal613_tree);
			}
			DebugLocation(638, 8);
			PushFollow(Follow._integral_type_in_enum_base4867);
			integral_type614=integral_type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, integral_type614.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("enum_base", 178);
			LeaveRule("enum_base", 178);
			Leave_enum_base();
			if (state.backtracking > 0) { Memoize(input, 178, enum_base_StartIndex); }
		}
		DebugLocation(638, 21);
		} finally { DebugExitRule(GrammarFileName, "enum_base"); }
		return retval;

	}
	// $ANTLR end "enum_base"

	public class enum_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_enum_body();
	partial void Leave_enum_body();

	// $ANTLR start "enum_body"
	// cs.g:639:8: public enum_body : '{' ( enum_member_declarations ( ',' )? )? '}' ;
	[GrammarRule("enum_body")]
	public csParser.enum_body_return enum_body()
	{
		Enter_enum_body();
		EnterRule("enum_body", 179);
		TraceIn("enum_body", 179);
		csParser.enum_body_return retval = new csParser.enum_body_return();
		retval.Start = (IToken)input.LT(1);
		int enum_body_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal615=null;
		IToken char_literal617=null;
		IToken char_literal618=null;
		csParser.enum_member_declarations_return enum_member_declarations616 = default(csParser.enum_member_declarations_return);

		object char_literal615_tree=null;
		object char_literal617_tree=null;
		object char_literal618_tree=null;

		try { DebugEnterRule(GrammarFileName, "enum_body");
		DebugLocation(639, 44);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 179)) { return retval; }
			// cs.g:639:17: ( '{' ( enum_member_declarations ( ',' )? )? '}' )
			DebugEnterAlt(1);
			// cs.g:640:2: '{' ( enum_member_declarations ( ',' )? )? '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(640, 2);
			char_literal615=(IToken)Match(input,62,Follow._62_in_enum_body4877); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal615_tree = (object)adaptor.Create(char_literal615);
			adaptor.AddChild(root_0, char_literal615_tree);
			}
			DebugLocation(640, 6);
			// cs.g:640:6: ( enum_member_declarations ( ',' )? )?
			int alt172=2;
			try { DebugEnterSubRule(172);
			try { DebugEnterDecision(172, decisionCanBacktrack[172]);
			int LA172_0 = input.LA(1);

			if ((LA172_0==IDENTIFIER||(LA172_0>=ELIF && LA172_0<=UNDEF)||LA172_0==65||LA172_0==88||(LA172_0>=132 && LA172_0<=133)||(LA172_0>=135 && LA172_0<=148)||(LA172_0>=150 && LA172_0<=152)||LA172_0==154||(LA172_0>=156 && LA172_0<=159)||LA172_0==170||(LA172_0>=177 && LA172_0<=178)||LA172_0==195||LA172_0==202))
			{
				alt172=1;
			}
			} finally { DebugExitDecision(172); }
			switch (alt172)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:640:7: enum_member_declarations ( ',' )?
				{
				DebugLocation(640, 7);
				PushFollow(Follow._enum_member_declarations_in_enum_body4880);
				enum_member_declarations616=enum_member_declarations();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_member_declarations616.Tree);
				DebugLocation(640, 32);
				// cs.g:640:32: ( ',' )?
				int alt171=2;
				try { DebugEnterSubRule(171);
				try { DebugEnterDecision(171, decisionCanBacktrack[171]);
				int LA171_0 = input.LA(1);

				if ((LA171_0==91))
				{
					alt171=1;
				}
				} finally { DebugExitDecision(171); }
				switch (alt171)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:640:32: ','
					{
					DebugLocation(640, 32);
					char_literal617=(IToken)Match(input,91,Follow._91_in_enum_body4882); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal617_tree = (object)adaptor.Create(char_literal617);
					adaptor.AddChild(root_0, char_literal617_tree);
					}

					}
					break;

				}
				} finally { DebugExitSubRule(171); }


				}
				break;

			}
			} finally { DebugExitSubRule(172); }

			DebugLocation(640, 41);
			char_literal618=(IToken)Match(input,63,Follow._63_in_enum_body4889); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal618_tree = (object)adaptor.Create(char_literal618);
			adaptor.AddChild(root_0, char_literal618_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("enum_body", 179);
			LeaveRule("enum_body", 179);
			Leave_enum_body();
			if (state.backtracking > 0) { Memoize(input, 179, enum_body_StartIndex); }
		}
		DebugLocation(640, 44);
		} finally { DebugExitRule(GrammarFileName, "enum_body"); }
		return retval;

	}
	// $ANTLR end "enum_body"

	public class enum_member_declarations_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_enum_member_declarations();
	partial void Leave_enum_member_declarations();

	// $ANTLR start "enum_member_declarations"
	// cs.g:641:8: public enum_member_declarations : enum_member_declaration ( ',' enum_member_declaration )* ;
	[GrammarRule("enum_member_declarations")]
	public csParser.enum_member_declarations_return enum_member_declarations()
	{
		Enter_enum_member_declarations();
		EnterRule("enum_member_declarations", 180);
		TraceIn("enum_member_declarations", 180);
		csParser.enum_member_declarations_return retval = new csParser.enum_member_declarations_return();
		retval.Start = (IToken)input.LT(1);
		int enum_member_declarations_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal620=null;
		csParser.enum_member_declaration_return enum_member_declaration619 = default(csParser.enum_member_declaration_return);
		csParser.enum_member_declaration_return enum_member_declaration621 = default(csParser.enum_member_declaration_return);

		object char_literal620_tree=null;

		try { DebugEnterRule(GrammarFileName, "enum_member_declarations");
		DebugLocation(641, 56);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 180)) { return retval; }
			// cs.g:641:32: ( enum_member_declaration ( ',' enum_member_declaration )* )
			DebugEnterAlt(1);
			// cs.g:642:2: enum_member_declaration ( ',' enum_member_declaration )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(642, 2);
			PushFollow(Follow._enum_member_declaration_in_enum_member_declarations4899);
			enum_member_declaration619=enum_member_declaration();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_member_declaration619.Tree);
			DebugLocation(642, 26);
			// cs.g:642:26: ( ',' enum_member_declaration )*
			try { DebugEnterSubRule(173);
			while (true)
			{
				int alt173=2;
				try { DebugEnterDecision(173, decisionCanBacktrack[173]);
				int LA173_0 = input.LA(1);

				if ((LA173_0==91))
				{
					int LA173_1 = input.LA(2);

					if ((LA173_1==IDENTIFIER||(LA173_1>=ELIF && LA173_1<=UNDEF)||LA173_1==65||LA173_1==88||(LA173_1>=132 && LA173_1<=133)||(LA173_1>=135 && LA173_1<=148)||(LA173_1>=150 && LA173_1<=152)||LA173_1==154||(LA173_1>=156 && LA173_1<=159)||LA173_1==170||(LA173_1>=177 && LA173_1<=178)||LA173_1==195||LA173_1==202))
					{
						alt173=1;
					}


				}


				} finally { DebugExitDecision(173); }
				switch ( alt173 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:642:27: ',' enum_member_declaration
					{
					DebugLocation(642, 27);
					char_literal620=(IToken)Match(input,91,Follow._91_in_enum_member_declarations4902); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal620_tree = (object)adaptor.Create(char_literal620);
					adaptor.AddChild(root_0, char_literal620_tree);
					}
					DebugLocation(642, 31);
					PushFollow(Follow._enum_member_declaration_in_enum_member_declarations4904);
					enum_member_declaration621=enum_member_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_member_declaration621.Tree);

					}
					break;

				default:
					goto loop173;
				}
			}

			loop173:
				;

			} finally { DebugExitSubRule(173); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("enum_member_declarations", 180);
			LeaveRule("enum_member_declarations", 180);
			Leave_enum_member_declarations();
			if (state.backtracking > 0) { Memoize(input, 180, enum_member_declarations_StartIndex); }
		}
		DebugLocation(642, 56);
		} finally { DebugExitRule(GrammarFileName, "enum_member_declarations"); }
		return retval;

	}
	// $ANTLR end "enum_member_declarations"

	public class enum_member_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_enum_member_declaration();
	partial void Leave_enum_member_declaration();

	// $ANTLR start "enum_member_declaration"
	// cs.g:643:8: public enum_member_declaration : ( attributes )? identifier ( '=' expression )? ;
	[GrammarRule("enum_member_declaration")]
	public csParser.enum_member_declaration_return enum_member_declaration()
	{
		Enter_enum_member_declaration();
		EnterRule("enum_member_declaration", 181);
		TraceIn("enum_member_declaration", 181);
		csParser.enum_member_declaration_return retval = new csParser.enum_member_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int enum_member_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal624=null;
		csParser.attributes_return attributes622 = default(csParser.attributes_return);
		csParser.identifier_return identifier623 = default(csParser.identifier_return);
		csParser.expression_return expression625 = default(csParser.expression_return);

		object char_literal624_tree=null;

		try { DebugEnterRule(GrammarFileName, "enum_member_declaration");
		DebugLocation(643, 48);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 181)) { return retval; }
			// cs.g:643:31: ( ( attributes )? identifier ( '=' expression )? )
			DebugEnterAlt(1);
			// cs.g:644:2: ( attributes )? identifier ( '=' expression )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(644, 2);
			// cs.g:644:2: ( attributes )?
			int alt174=2;
			try { DebugEnterSubRule(174);
			try { DebugEnterDecision(174, decisionCanBacktrack[174]);
			int LA174_0 = input.LA(1);

			if ((LA174_0==88))
			{
				alt174=1;
			}
			} finally { DebugExitDecision(174); }
			switch (alt174)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:644:2: attributes
				{
				DebugLocation(644, 2);
				PushFollow(Follow._attributes_in_enum_member_declaration4916);
				attributes622=attributes();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes622.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(174); }

			DebugLocation(644, 16);
			PushFollow(Follow._identifier_in_enum_member_declaration4921);
			identifier623=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier623.Tree);
			DebugLocation(644, 29);
			// cs.g:644:29: ( '=' expression )?
			int alt175=2;
			try { DebugEnterSubRule(175);
			try { DebugEnterDecision(175, decisionCanBacktrack[175]);
			int LA175_0 = input.LA(1);

			if ((LA175_0==66))
			{
				alt175=1;
			}
			} finally { DebugExitDecision(175); }
			switch (alt175)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:644:30: '=' expression
				{
				DebugLocation(644, 30);
				char_literal624=(IToken)Match(input,66,Follow._66_in_enum_member_declaration4926); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal624_tree = (object)adaptor.Create(char_literal624);
				adaptor.AddChild(root_0, char_literal624_tree);
				}
				DebugLocation(644, 36);
				PushFollow(Follow._expression_in_enum_member_declaration4930);
				expression625=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression625.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(175); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("enum_member_declaration", 181);
			LeaveRule("enum_member_declaration", 181);
			Leave_enum_member_declaration();
			if (state.backtracking > 0) { Memoize(input, 181, enum_member_declaration_StartIndex); }
		}
		DebugLocation(644, 48);
		} finally { DebugExitRule(GrammarFileName, "enum_member_declaration"); }
		return retval;

	}
	// $ANTLR end "enum_member_declaration"

	public class integral_type_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_integral_type();
	partial void Leave_integral_type();

	// $ANTLR start "integral_type"
	// cs.g:649:8: public integral_type : ( 'sbyte' | 'byte' | 'short' | 'ushort' | 'int' | 'uint' | 'long' | 'ulong' | 'char' );
	[GrammarRule("integral_type")]
	public csParser.integral_type_return integral_type()
	{
		Enter_integral_type();
		EnterRule("integral_type", 182);
		TraceIn("integral_type", 182);
		csParser.integral_type_return retval = new csParser.integral_type_return();
		retval.Start = (IToken)input.LT(1);
		int integral_type_StartIndex = input.Index;
		object root_0 = null;

		IToken set626=null;

		object set626_tree=null;

		try { DebugEnterRule(GrammarFileName, "integral_type");
		DebugLocation(649, 84);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 182)) { return retval; }
			// cs.g:649:21: ( 'sbyte' | 'byte' | 'short' | 'ushort' | 'int' | 'uint' | 'long' | 'ulong' | 'char' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(649, 21);
			set626=(IToken)input.LT(1);
			if ((input.LA(1)>=160 && input.LA(1)<=168))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set626));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("integral_type", 182);
			LeaveRule("integral_type", 182);
			Leave_integral_type();
			if (state.backtracking > 0) { Memoize(input, 182, integral_type_StartIndex); }
		}
		DebugLocation(650, 84);
		} finally { DebugExitRule(GrammarFileName, "integral_type"); }
		return retval;

	}
	// $ANTLR end "integral_type"

	public class delegate_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_delegate_declaration();
	partial void Leave_delegate_declaration();

	// $ANTLR start "delegate_declaration"
	// cs.g:653:8: public delegate_declaration : 'delegate' return_type identifier ( variant_generic_parameter_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';' ;
	[GrammarRule("delegate_declaration")]
	public csParser.delegate_declaration_return delegate_declaration()
	{
		Enter_delegate_declaration();
		EnterRule("delegate_declaration", 183);
		TraceIn("delegate_declaration", 183);
		csParser.delegate_declaration_return retval = new csParser.delegate_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int delegate_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal627=null;
		IToken char_literal631=null;
		IToken char_literal633=null;
		IToken char_literal635=null;
		csParser.return_type_return return_type628 = default(csParser.return_type_return);
		csParser.identifier_return identifier629 = default(csParser.identifier_return);
		csParser.variant_generic_parameter_list_return variant_generic_parameter_list630 = default(csParser.variant_generic_parameter_list_return);
		csParser.formal_parameter_list_return formal_parameter_list632 = default(csParser.formal_parameter_list_return);
		csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses634 = default(csParser.type_parameter_constraints_clauses_return);

		object string_literal627_tree=null;
		object char_literal631_tree=null;
		object char_literal633_tree=null;
		object char_literal635_tree=null;

		try { DebugEnterRule(GrammarFileName, "delegate_declaration");
		DebugLocation(653, 81);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 183)) { return retval; }
			// cs.g:653:28: ( 'delegate' return_type identifier ( variant_generic_parameter_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';' )
			DebugEnterAlt(1);
			// cs.g:654:2: 'delegate' return_type identifier ( variant_generic_parameter_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(654, 2);
			string_literal627=(IToken)Match(input,99,Follow._99_in_delegate_declaration4991); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal627_tree = (object)adaptor.Create(string_literal627);
			adaptor.AddChild(root_0, string_literal627_tree);
			}
			DebugLocation(654, 15);
			PushFollow(Follow._return_type_in_delegate_declaration4995);
			return_type628=return_type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, return_type628.Tree);
			DebugLocation(654, 29);
			PushFollow(Follow._identifier_in_delegate_declaration4999);
			identifier629=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier629.Tree);
			DebugLocation(654, 41);
			// cs.g:654:41: ( variant_generic_parameter_list )?
			int alt176=2;
			try { DebugEnterSubRule(176);
			try { DebugEnterDecision(176, decisionCanBacktrack[176]);
			int LA176_0 = input.LA(1);

			if ((LA176_0==101))
			{
				alt176=1;
			}
			} finally { DebugExitDecision(176); }
			switch (alt176)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:654:41: variant_generic_parameter_list
				{
				DebugLocation(654, 41);
				PushFollow(Follow._variant_generic_parameter_list_in_delegate_declaration5002);
				variant_generic_parameter_list630=variant_generic_parameter_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variant_generic_parameter_list630.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(176); }

			DebugLocation(655, 3);
			char_literal631=(IToken)Match(input,90,Follow._90_in_delegate_declaration5010); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal631_tree = (object)adaptor.Create(char_literal631);
			adaptor.AddChild(root_0, char_literal631_tree);
			}
			DebugLocation(655, 9);
			// cs.g:655:9: ( formal_parameter_list )?
			int alt177=2;
			try { DebugEnterSubRule(177);
			try { DebugEnterDecision(177, decisionCanBacktrack[177]);
			int LA177_0 = input.LA(1);

			if ((LA177_0==IDENTIFIER||(LA177_0>=ELIF && LA177_0<=UNDEF)||LA177_0==65||(LA177_0>=82 && LA177_0<=83)||LA177_0==88||(LA177_0>=93 && LA177_0<=94)||(LA177_0>=132 && LA177_0<=133)||(LA177_0>=135 && LA177_0<=148)||(LA177_0>=150 && LA177_0<=152)||LA177_0==154||(LA177_0>=156 && LA177_0<=168)||(LA177_0>=170 && LA177_0<=171)||(LA177_0>=177 && LA177_0<=178)||(LA177_0>=195 && LA177_0<=202)))
			{
				alt177=1;
			}
			} finally { DebugExitDecision(177); }
			switch (alt177)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:655:9: formal_parameter_list
				{
				DebugLocation(655, 9);
				PushFollow(Follow._formal_parameter_list_in_delegate_declaration5014);
				formal_parameter_list632=formal_parameter_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list632.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(177); }

			DebugLocation(655, 34);
			char_literal633=(IToken)Match(input,RPAREN,Follow._RPAREN_in_delegate_declaration5019); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal633_tree = (object)adaptor.Create(char_literal633);
			adaptor.AddChild(root_0, char_literal633_tree);
			}
			DebugLocation(655, 40);
			// cs.g:655:40: ( type_parameter_constraints_clauses )?
			int alt178=2;
			try { DebugEnterSubRule(178);
			try { DebugEnterDecision(178, decisionCanBacktrack[178]);
			int LA178_0 = input.LA(1);

			if ((LA178_0==145))
			{
				alt178=1;
			}
			} finally { DebugExitDecision(178); }
			switch (alt178)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:655:40: type_parameter_constraints_clauses
				{
				DebugLocation(655, 40);
				PushFollow(Follow._type_parameter_constraints_clauses_in_delegate_declaration5023);
				type_parameter_constraints_clauses634=type_parameter_constraints_clauses();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses634.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(178); }

			DebugLocation(655, 78);
			char_literal635=(IToken)Match(input,SEMI,Follow._SEMI_in_delegate_declaration5028); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal635_tree = (object)adaptor.Create(char_literal635);
			adaptor.AddChild(root_0, char_literal635_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("delegate_declaration", 183);
			LeaveRule("delegate_declaration", 183);
			Leave_delegate_declaration();
			if (state.backtracking > 0) { Memoize(input, 183, delegate_declaration_StartIndex); }
		}
		DebugLocation(655, 81);
		} finally { DebugExitRule(GrammarFileName, "delegate_declaration"); }
		return retval;

	}
	// $ANTLR end "delegate_declaration"

	public class delegate_modifiers_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_delegate_modifiers();
	partial void Leave_delegate_modifiers();

	// $ANTLR start "delegate_modifiers"
	// cs.g:656:8: public delegate_modifiers : ( modifier )+ ;
	[GrammarRule("delegate_modifiers")]
	public csParser.delegate_modifiers_return delegate_modifiers()
	{
		Enter_delegate_modifiers();
		EnterRule("delegate_modifiers", 184);
		TraceIn("delegate_modifiers", 184);
		csParser.delegate_modifiers_return retval = new csParser.delegate_modifiers_return();
		retval.Start = (IToken)input.LT(1);
		int delegate_modifiers_StartIndex = input.Index;
		object root_0 = null;

		csParser.modifier_return modifier636 = default(csParser.modifier_return);


		try { DebugEnterRule(GrammarFileName, "delegate_modifiers");
		DebugLocation(656, 11);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 184)) { return retval; }
			// cs.g:656:26: ( ( modifier )+ )
			DebugEnterAlt(1);
			// cs.g:657:2: ( modifier )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(657, 2);
			// cs.g:657:2: ( modifier )+
			int cnt179=0;
			try { DebugEnterSubRule(179);
			while (true)
			{
				int alt179=2;
				try { DebugEnterDecision(179, decisionCanBacktrack[179]);
				int LA179_0 = input.LA(1);

				if ((LA179_0==64||(LA179_0>=68 && LA179_0<=80)))
				{
					alt179=1;
				}


				} finally { DebugExitDecision(179); }
				switch (alt179)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:657:2: modifier
					{
					DebugLocation(657, 2);
					PushFollow(Follow._modifier_in_delegate_modifiers5038);
					modifier636=modifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifier636.Tree);

					}
					break;

				default:
					if (cnt179 >= 1)
						goto loop179;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee179 = new EarlyExitException( 179, input );
					DebugRecognitionException(eee179);
					throw eee179;
				}
				cnt179++;
			}
			loop179:
				;

			} finally { DebugExitSubRule(179); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("delegate_modifiers", 184);
			LeaveRule("delegate_modifiers", 184);
			Leave_delegate_modifiers();
			if (state.backtracking > 0) { Memoize(input, 184, delegate_modifiers_StartIndex); }
		}
		DebugLocation(657, 11);
		} finally { DebugExitRule(GrammarFileName, "delegate_modifiers"); }
		return retval;

	}
	// $ANTLR end "delegate_modifiers"

	public class variant_generic_parameter_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_variant_generic_parameter_list();
	partial void Leave_variant_generic_parameter_list();

	// $ANTLR start "variant_generic_parameter_list"
	// cs.g:659:8: public variant_generic_parameter_list : '<' variant_type_parameters '>' ;
	[GrammarRule("variant_generic_parameter_list")]
	public csParser.variant_generic_parameter_list_return variant_generic_parameter_list()
	{
		Enter_variant_generic_parameter_list();
		EnterRule("variant_generic_parameter_list", 185);
		TraceIn("variant_generic_parameter_list", 185);
		csParser.variant_generic_parameter_list_return retval = new csParser.variant_generic_parameter_list_return();
		retval.Start = (IToken)input.LT(1);
		int variant_generic_parameter_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal637=null;
		IToken char_literal639=null;
		csParser.variant_type_parameters_return variant_type_parameters638 = default(csParser.variant_type_parameters_return);

		object char_literal637_tree=null;
		object char_literal639_tree=null;

		try { DebugEnterRule(GrammarFileName, "variant_generic_parameter_list");
		DebugLocation(659, 37);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 185)) { return retval; }
			// cs.g:659:38: ( '<' variant_type_parameters '>' )
			DebugEnterAlt(1);
			// cs.g:660:2: '<' variant_type_parameters '>'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(660, 2);
			char_literal637=(IToken)Match(input,101,Follow._101_in_variant_generic_parameter_list5050); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal637_tree = (object)adaptor.Create(char_literal637);
			adaptor.AddChild(root_0, char_literal637_tree);
			}
			DebugLocation(660, 8);
			PushFollow(Follow._variant_type_parameters_in_variant_generic_parameter_list5054);
			variant_type_parameters638=variant_type_parameters();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variant_type_parameters638.Tree);
			DebugLocation(660, 34);
			char_literal639=(IToken)Match(input,GT,Follow._GT_in_variant_generic_parameter_list5058); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal639_tree = (object)adaptor.Create(char_literal639);
			adaptor.AddChild(root_0, char_literal639_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("variant_generic_parameter_list", 185);
			LeaveRule("variant_generic_parameter_list", 185);
			Leave_variant_generic_parameter_list();
			if (state.backtracking > 0) { Memoize(input, 185, variant_generic_parameter_list_StartIndex); }
		}
		DebugLocation(660, 37);
		} finally { DebugExitRule(GrammarFileName, "variant_generic_parameter_list"); }
		return retval;

	}
	// $ANTLR end "variant_generic_parameter_list"

	public class variant_type_parameters_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_variant_type_parameters();
	partial void Leave_variant_type_parameters();

	// $ANTLR start "variant_type_parameters"
	// cs.g:661:8: public variant_type_parameters : variant_type_variable_name ( ',' variant_type_variable_name )* ;
	[GrammarRule("variant_type_parameters")]
	public csParser.variant_type_parameters_return variant_type_parameters()
	{
		Enter_variant_type_parameters();
		EnterRule("variant_type_parameters", 186);
		TraceIn("variant_type_parameters", 186);
		csParser.variant_type_parameters_return retval = new csParser.variant_type_parameters_return();
		retval.Start = (IToken)input.LT(1);
		int variant_type_parameters_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal641=null;
		csParser.variant_type_variable_name_return variant_type_variable_name640 = default(csParser.variant_type_variable_name_return);
		csParser.variant_type_variable_name_return variant_type_variable_name642 = default(csParser.variant_type_variable_name_return);

		object char_literal641_tree=null;

		try { DebugEnterRule(GrammarFileName, "variant_type_parameters");
		DebugLocation(661, 62);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 186)) { return retval; }
			// cs.g:661:31: ( variant_type_variable_name ( ',' variant_type_variable_name )* )
			DebugEnterAlt(1);
			// cs.g:662:2: variant_type_variable_name ( ',' variant_type_variable_name )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(662, 2);
			PushFollow(Follow._variant_type_variable_name_in_variant_type_parameters5068);
			variant_type_variable_name640=variant_type_variable_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variant_type_variable_name640.Tree);
			DebugLocation(662, 29);
			// cs.g:662:29: ( ',' variant_type_variable_name )*
			try { DebugEnterSubRule(180);
			while (true)
			{
				int alt180=2;
				try { DebugEnterDecision(180, decisionCanBacktrack[180]);
				int LA180_0 = input.LA(1);

				if ((LA180_0==91))
				{
					alt180=1;
				}


				} finally { DebugExitDecision(180); }
				switch ( alt180 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:662:30: ',' variant_type_variable_name
					{
					DebugLocation(662, 30);
					char_literal641=(IToken)Match(input,91,Follow._91_in_variant_type_parameters5071); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal641_tree = (object)adaptor.Create(char_literal641);
					adaptor.AddChild(root_0, char_literal641_tree);
					}
					DebugLocation(662, 34);
					PushFollow(Follow._variant_type_variable_name_in_variant_type_parameters5073);
					variant_type_variable_name642=variant_type_variable_name();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variant_type_variable_name642.Tree);

					}
					break;

				default:
					goto loop180;
				}
			}

			loop180:
				;

			} finally { DebugExitSubRule(180); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("variant_type_parameters", 186);
			LeaveRule("variant_type_parameters", 186);
			Leave_variant_type_parameters();
			if (state.backtracking > 0) { Memoize(input, 186, variant_type_parameters_StartIndex); }
		}
		DebugLocation(662, 62);
		} finally { DebugExitRule(GrammarFileName, "variant_type_parameters"); }
		return retval;

	}
	// $ANTLR end "variant_type_parameters"

	public class variant_type_variable_name_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_variant_type_variable_name();
	partial void Leave_variant_type_variable_name();

	// $ANTLR start "variant_type_variable_name"
	// cs.g:663:8: public variant_type_variable_name : ( attributes )? ( variance_annotation )? type_variable_name ;
	[GrammarRule("variant_type_variable_name")]
	public csParser.variant_type_variable_name_return variant_type_variable_name()
	{
		Enter_variant_type_variable_name();
		EnterRule("variant_type_variable_name", 187);
		TraceIn("variant_type_variable_name", 187);
		csParser.variant_type_variable_name_return retval = new csParser.variant_type_variable_name_return();
		retval.Start = (IToken)input.LT(1);
		int variant_type_variable_name_StartIndex = input.Index;
		object root_0 = null;

		csParser.attributes_return attributes643 = default(csParser.attributes_return);
		csParser.variance_annotation_return variance_annotation644 = default(csParser.variance_annotation_return);
		csParser.type_variable_name_return type_variable_name645 = default(csParser.type_variable_name_return);


		try { DebugEnterRule(GrammarFileName, "variant_type_variable_name");
		DebugLocation(663, 57);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 187)) { return retval; }
			// cs.g:663:34: ( ( attributes )? ( variance_annotation )? type_variable_name )
			DebugEnterAlt(1);
			// cs.g:664:2: ( attributes )? ( variance_annotation )? type_variable_name
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(664, 2);
			// cs.g:664:2: ( attributes )?
			int alt181=2;
			try { DebugEnterSubRule(181);
			try { DebugEnterDecision(181, decisionCanBacktrack[181]);
			int LA181_0 = input.LA(1);

			if ((LA181_0==88))
			{
				alt181=1;
			}
			} finally { DebugExitDecision(181); }
			switch (alt181)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:664:2: attributes
				{
				DebugLocation(664, 2);
				PushFollow(Follow._attributes_in_variant_type_variable_name5085);
				attributes643=attributes();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes643.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(181); }

			DebugLocation(664, 16);
			// cs.g:664:16: ( variance_annotation )?
			int alt182=2;
			try { DebugEnterSubRule(182);
			try { DebugEnterDecision(182, decisionCanBacktrack[182]);
			int LA182_0 = input.LA(1);

			if ((LA182_0==93||LA182_0==134))
			{
				alt182=1;
			}
			} finally { DebugExitDecision(182); }
			switch (alt182)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:664:16: variance_annotation
				{
				DebugLocation(664, 16);
				PushFollow(Follow._variance_annotation_in_variant_type_variable_name5090);
				variance_annotation644=variance_annotation();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variance_annotation644.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(182); }

			DebugLocation(664, 39);
			PushFollow(Follow._type_variable_name_in_variant_type_variable_name5095);
			type_variable_name645=type_variable_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_variable_name645.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("variant_type_variable_name", 187);
			LeaveRule("variant_type_variable_name", 187);
			Leave_variant_type_variable_name();
			if (state.backtracking > 0) { Memoize(input, 187, variant_type_variable_name_StartIndex); }
		}
		DebugLocation(664, 57);
		} finally { DebugExitRule(GrammarFileName, "variant_type_variable_name"); }
		return retval;

	}
	// $ANTLR end "variant_type_variable_name"

	public class variance_annotation_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_variance_annotation();
	partial void Leave_variance_annotation();

	// $ANTLR start "variance_annotation"
	// cs.g:665:8: public variance_annotation : ( 'in' | 'out' );
	[GrammarRule("variance_annotation")]
	public csParser.variance_annotation_return variance_annotation()
	{
		Enter_variance_annotation();
		EnterRule("variance_annotation", 188);
		TraceIn("variance_annotation", 188);
		csParser.variance_annotation_return retval = new csParser.variance_annotation_return();
		retval.Start = (IToken)input.LT(1);
		int variance_annotation_StartIndex = input.Index;
		object root_0 = null;

		IToken set646=null;

		object set646_tree=null;

		try { DebugEnterRule(GrammarFileName, "variance_annotation");
		DebugLocation(665, 14);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 188)) { return retval; }
			// cs.g:665:27: ( 'in' | 'out' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(665, 27);
			set646=(IToken)input.LT(1);
			if (input.LA(1)==93||input.LA(1)==134)
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set646));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("variance_annotation", 188);
			LeaveRule("variance_annotation", 188);
			Leave_variance_annotation();
			if (state.backtracking > 0) { Memoize(input, 188, variance_annotation_StartIndex); }
		}
		DebugLocation(666, 14);
		} finally { DebugExitRule(GrammarFileName, "variance_annotation"); }
		return retval;

	}
	// $ANTLR end "variance_annotation"

	public class type_parameter_constraints_clauses_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_type_parameter_constraints_clauses();
	partial void Leave_type_parameter_constraints_clauses();

	// $ANTLR start "type_parameter_constraints_clauses"
	// cs.g:668:8: public type_parameter_constraints_clauses : type_parameter_constraints_clause ( ',' type_parameter_constraints_clause )* ;
	[GrammarRule("type_parameter_constraints_clauses")]
	public csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses()
	{
		Enter_type_parameter_constraints_clauses();
		EnterRule("type_parameter_constraints_clauses", 189);
		TraceIn("type_parameter_constraints_clauses", 189);
		csParser.type_parameter_constraints_clauses_return retval = new csParser.type_parameter_constraints_clauses_return();
		retval.Start = (IToken)input.LT(1);
		int type_parameter_constraints_clauses_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal648=null;
		csParser.type_parameter_constraints_clause_return type_parameter_constraints_clause647 = default(csParser.type_parameter_constraints_clause_return);
		csParser.type_parameter_constraints_clause_return type_parameter_constraints_clause649 = default(csParser.type_parameter_constraints_clause_return);

		object char_literal648_tree=null;

		try { DebugEnterRule(GrammarFileName, "type_parameter_constraints_clauses");
		DebugLocation(668, 80);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 189)) { return retval; }
			// cs.g:668:42: ( type_parameter_constraints_clause ( ',' type_parameter_constraints_clause )* )
			DebugEnterAlt(1);
			// cs.g:669:2: type_parameter_constraints_clause ( ',' type_parameter_constraints_clause )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(669, 2);
			PushFollow(Follow._type_parameter_constraints_clause_in_type_parameter_constraints_clauses5120);
			type_parameter_constraints_clause647=type_parameter_constraints_clause();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clause647.Tree);
			DebugLocation(669, 38);
			// cs.g:669:38: ( ',' type_parameter_constraints_clause )*
			try { DebugEnterSubRule(183);
			while (true)
			{
				int alt183=2;
				try { DebugEnterDecision(183, decisionCanBacktrack[183]);
				int LA183_0 = input.LA(1);

				if ((LA183_0==91))
				{
					alt183=1;
				}


				} finally { DebugExitDecision(183); }
				switch ( alt183 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:669:39: ',' type_parameter_constraints_clause
					{
					DebugLocation(669, 39);
					char_literal648=(IToken)Match(input,91,Follow._91_in_type_parameter_constraints_clauses5125); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal648_tree = (object)adaptor.Create(char_literal648);
					adaptor.AddChild(root_0, char_literal648_tree);
					}
					DebugLocation(669, 45);
					PushFollow(Follow._type_parameter_constraints_clause_in_type_parameter_constraints_clauses5129);
					type_parameter_constraints_clause649=type_parameter_constraints_clause();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clause649.Tree);

					}
					break;

				default:
					goto loop183;
				}
			}

			loop183:
				;

			} finally { DebugExitSubRule(183); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("type_parameter_constraints_clauses", 189);
			LeaveRule("type_parameter_constraints_clauses", 189);
			Leave_type_parameter_constraints_clauses();
			if (state.backtracking > 0) { Memoize(input, 189, type_parameter_constraints_clauses_StartIndex); }
		}
		DebugLocation(669, 80);
		} finally { DebugExitRule(GrammarFileName, "type_parameter_constraints_clauses"); }
		return retval;

	}
	// $ANTLR end "type_parameter_constraints_clauses"

	public class type_parameter_constraints_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_type_parameter_constraints_clause();
	partial void Leave_type_parameter_constraints_clause();

	// $ANTLR start "type_parameter_constraints_clause"
	// cs.g:670:8: public type_parameter_constraints_clause : 'where' type_variable_name ':' type_parameter_constraint_list ;
	[GrammarRule("type_parameter_constraints_clause")]
	public csParser.type_parameter_constraints_clause_return type_parameter_constraints_clause()
	{
		Enter_type_parameter_constraints_clause();
		EnterRule("type_parameter_constraints_clause", 190);
		TraceIn("type_parameter_constraints_clause", 190);
		csParser.type_parameter_constraints_clause_return retval = new csParser.type_parameter_constraints_clause_return();
		retval.Start = (IToken)input.LT(1);
		int type_parameter_constraints_clause_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal650=null;
		IToken char_literal652=null;
		csParser.type_variable_name_return type_variable_name651 = default(csParser.type_variable_name_return);
		csParser.type_parameter_constraint_list_return type_parameter_constraint_list653 = default(csParser.type_parameter_constraint_list_return);

		object string_literal650_tree=null;
		object char_literal652_tree=null;

		try { DebugEnterRule(GrammarFileName, "type_parameter_constraints_clause");
		DebugLocation(670, 69);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 190)) { return retval; }
			// cs.g:670:41: ( 'where' type_variable_name ':' type_parameter_constraint_list )
			DebugEnterAlt(1);
			// cs.g:671:2: 'where' type_variable_name ':' type_parameter_constraint_list
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(671, 2);
			string_literal650=(IToken)Match(input,145,Follow._145_in_type_parameter_constraints_clause5141); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal650_tree = (object)adaptor.Create(string_literal650);
			adaptor.AddChild(root_0, string_literal650_tree);
			}
			DebugLocation(671, 12);
			PushFollow(Follow._type_variable_name_in_type_parameter_constraints_clause5145);
			type_variable_name651=type_variable_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_variable_name651.Tree);
			DebugLocation(671, 33);
			char_literal652=(IToken)Match(input,92,Follow._92_in_type_parameter_constraints_clause5149); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal652_tree = (object)adaptor.Create(char_literal652);
			adaptor.AddChild(root_0, char_literal652_tree);
			}
			DebugLocation(671, 39);
			PushFollow(Follow._type_parameter_constraint_list_in_type_parameter_constraints_clause5153);
			type_parameter_constraint_list653=type_parameter_constraint_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraint_list653.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("type_parameter_constraints_clause", 190);
			LeaveRule("type_parameter_constraints_clause", 190);
			Leave_type_parameter_constraints_clause();
			if (state.backtracking > 0) { Memoize(input, 190, type_parameter_constraints_clause_StartIndex); }
		}
		DebugLocation(671, 69);
		} finally { DebugExitRule(GrammarFileName, "type_parameter_constraints_clause"); }
		return retval;

	}
	// $ANTLR end "type_parameter_constraints_clause"

	public class type_parameter_constraint_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_type_parameter_constraint_list();
	partial void Leave_type_parameter_constraint_list();

	// $ANTLR start "type_parameter_constraint_list"
	// cs.g:673:8: public type_parameter_constraint_list : ( ( 'class' | 'struct' ) ( ',' secondary_constraint_list )? ( ',' constructor_constraint )? | secondary_constraint_list ( ',' constructor_constraint )? | constructor_constraint );
	[GrammarRule("type_parameter_constraint_list")]
	public csParser.type_parameter_constraint_list_return type_parameter_constraint_list()
	{
		Enter_type_parameter_constraint_list();
		EnterRule("type_parameter_constraint_list", 191);
		TraceIn("type_parameter_constraint_list", 191);
		csParser.type_parameter_constraint_list_return retval = new csParser.type_parameter_constraint_list_return();
		retval.Start = (IToken)input.LT(1);
		int type_parameter_constraint_list_StartIndex = input.Index;
		object root_0 = null;

		IToken set654=null;
		IToken char_literal655=null;
		IToken char_literal657=null;
		IToken char_literal660=null;
		csParser.secondary_constraint_list_return secondary_constraint_list656 = default(csParser.secondary_constraint_list_return);
		csParser.constructor_constraint_return constructor_constraint658 = default(csParser.constructor_constraint_return);
		csParser.secondary_constraint_list_return secondary_constraint_list659 = default(csParser.secondary_constraint_list_return);
		csParser.constructor_constraint_return constructor_constraint661 = default(csParser.constructor_constraint_return);
		csParser.constructor_constraint_return constructor_constraint662 = default(csParser.constructor_constraint_return);

		object set654_tree=null;
		object char_literal655_tree=null;
		object char_literal657_tree=null;
		object char_literal660_tree=null;

		try { DebugEnterRule(GrammarFileName, "type_parameter_constraint_list");
		DebugLocation(673, 26);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 191)) { return retval; }
			// cs.g:673:38: ( ( 'class' | 'struct' ) ( ',' secondary_constraint_list )? ( ',' constructor_constraint )? | secondary_constraint_list ( ',' constructor_constraint )? | constructor_constraint )
			int alt187=3;
			try { DebugEnterDecision(187, decisionCanBacktrack[187]);
			switch (input.LA(1))
			{
			case 155:
			case 169:
				{
				alt187=1;
				}
				break;
			case IDENTIFIER:
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 132:
			case 133:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 170:
			case 177:
			case 178:
			case 195:
			case 202:
				{
				alt187=2;
				}
				break;
			case 68:
				{
				alt187=3;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 187, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(187); }
			switch (alt187)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:674:5: ( 'class' | 'struct' ) ( ',' secondary_constraint_list )? ( ',' constructor_constraint )?
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(674, 5);
				set654=(IToken)input.LT(1);
				if (input.LA(1)==155||input.LA(1)==169)
				{
					input.Consume();
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set654));
					state.errorRecovery=false;state.failed=false;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					MismatchedSetException mse = new MismatchedSetException(null,input);
					DebugRecognitionException(mse);
					throw mse;
				}

				DebugLocation(674, 28);
				// cs.g:674:28: ( ',' secondary_constraint_list )?
				int alt184=2;
				try { DebugEnterSubRule(184);
				try { DebugEnterDecision(184, decisionCanBacktrack[184]);
				int LA184_0 = input.LA(1);

				if ((LA184_0==91))
				{
					int LA184_1 = input.LA(2);

					if ((LA184_1==IDENTIFIER||(LA184_1>=ELIF && LA184_1<=UNDEF)||LA184_1==65||(LA184_1>=132 && LA184_1<=133)||(LA184_1>=135 && LA184_1<=144)||(LA184_1>=146 && LA184_1<=148)||(LA184_1>=150 && LA184_1<=152)||LA184_1==154||(LA184_1>=156 && LA184_1<=159)||LA184_1==170||(LA184_1>=177 && LA184_1<=178)||LA184_1==195||LA184_1==202))
					{
						alt184=1;
					}
					else if ((LA184_1==145))
					{
						int LA184_4 = input.LA(3);

						if ((LA184_4==DOT||LA184_4==SEMI||LA184_4==62||LA184_4==85||LA184_4==91||LA184_4==101))
						{
							alt184=1;
						}
					}
				}
				} finally { DebugExitDecision(184); }
				switch (alt184)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:674:29: ',' secondary_constraint_list
					{
					DebugLocation(674, 29);
					char_literal655=(IToken)Match(input,91,Follow._91_in_type_parameter_constraint_list5229); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal655_tree = (object)adaptor.Create(char_literal655);
					adaptor.AddChild(root_0, char_literal655_tree);
					}
					DebugLocation(674, 35);
					PushFollow(Follow._secondary_constraint_list_in_type_parameter_constraint_list5233);
					secondary_constraint_list656=secondary_constraint_list();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, secondary_constraint_list656.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(184); }

				DebugLocation(674, 65);
				// cs.g:674:65: ( ',' constructor_constraint )?
				int alt185=2;
				try { DebugEnterSubRule(185);
				try { DebugEnterDecision(185, decisionCanBacktrack[185]);
				int LA185_0 = input.LA(1);

				if ((LA185_0==91))
				{
					int LA185_1 = input.LA(2);

					if ((LA185_1==68))
					{
						alt185=1;
					}
				}
				} finally { DebugExitDecision(185); }
				switch (alt185)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:674:66: ',' constructor_constraint
					{
					DebugLocation(674, 66);
					char_literal657=(IToken)Match(input,91,Follow._91_in_type_parameter_constraint_list5240); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal657_tree = (object)adaptor.Create(char_literal657);
					adaptor.AddChild(root_0, char_literal657_tree);
					}
					DebugLocation(674, 72);
					PushFollow(Follow._constructor_constraint_in_type_parameter_constraint_list5244);
					constructor_constraint658=constructor_constraint();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_constraint658.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(185); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:675:4: secondary_constraint_list ( ',' constructor_constraint )?
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(675, 4);
				PushFollow(Follow._secondary_constraint_list_in_type_parameter_constraint_list5251);
				secondary_constraint_list659=secondary_constraint_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, secondary_constraint_list659.Tree);
				DebugLocation(675, 32);
				// cs.g:675:32: ( ',' constructor_constraint )?
				int alt186=2;
				try { DebugEnterSubRule(186);
				try { DebugEnterDecision(186, decisionCanBacktrack[186]);
				int LA186_0 = input.LA(1);

				if ((LA186_0==91))
				{
					int LA186_1 = input.LA(2);

					if ((LA186_1==68))
					{
						alt186=1;
					}
				}
				} finally { DebugExitDecision(186); }
				switch (alt186)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:675:33: ',' constructor_constraint
					{
					DebugLocation(675, 33);
					char_literal660=(IToken)Match(input,91,Follow._91_in_type_parameter_constraint_list5256); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal660_tree = (object)adaptor.Create(char_literal660);
					adaptor.AddChild(root_0, char_literal660_tree);
					}
					DebugLocation(675, 39);
					PushFollow(Follow._constructor_constraint_in_type_parameter_constraint_list5260);
					constructor_constraint661=constructor_constraint();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_constraint661.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(186); }


				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:676:4: constructor_constraint
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(676, 4);
				PushFollow(Follow._constructor_constraint_in_type_parameter_constraint_list5267);
				constructor_constraint662=constructor_constraint();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_constraint662.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("type_parameter_constraint_list", 191);
			LeaveRule("type_parameter_constraint_list", 191);
			Leave_type_parameter_constraint_list();
			if (state.backtracking > 0) { Memoize(input, 191, type_parameter_constraint_list_StartIndex); }
		}
		DebugLocation(676, 26);
		} finally { DebugExitRule(GrammarFileName, "type_parameter_constraint_list"); }
		return retval;

	}
	// $ANTLR end "type_parameter_constraint_list"

	public class secondary_constraint_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_secondary_constraint_list();
	partial void Leave_secondary_constraint_list();

	// $ANTLR start "secondary_constraint_list"
	// cs.g:681:8: public secondary_constraint_list : secondary_constraint ( ',' secondary_constraint )* ;
	[GrammarRule("secondary_constraint_list")]
	public csParser.secondary_constraint_list_return secondary_constraint_list()
	{
		Enter_secondary_constraint_list();
		EnterRule("secondary_constraint_list", 192);
		TraceIn("secondary_constraint_list", 192);
		csParser.secondary_constraint_list_return retval = new csParser.secondary_constraint_list_return();
		retval.Start = (IToken)input.LT(1);
		int secondary_constraint_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal664=null;
		csParser.secondary_constraint_return secondary_constraint663 = default(csParser.secondary_constraint_return);
		csParser.secondary_constraint_return secondary_constraint665 = default(csParser.secondary_constraint_return);

		object char_literal664_tree=null;

		try { DebugEnterRule(GrammarFileName, "secondary_constraint_list");
		DebugLocation(681, 50);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 192)) { return retval; }
			// cs.g:681:33: ( secondary_constraint ( ',' secondary_constraint )* )
			DebugEnterAlt(1);
			// cs.g:682:2: secondary_constraint ( ',' secondary_constraint )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(682, 2);
			PushFollow(Follow._secondary_constraint_in_secondary_constraint_list5281);
			secondary_constraint663=secondary_constraint();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, secondary_constraint663.Tree);
			DebugLocation(682, 23);
			// cs.g:682:23: ( ',' secondary_constraint )*
			try { DebugEnterSubRule(188);
			while (true)
			{
				int alt188=2;
				try { DebugEnterDecision(188, decisionCanBacktrack[188]);
				int LA188_0 = input.LA(1);

				if ((LA188_0==91))
				{
					int LA188_1 = input.LA(2);

					if ((LA188_1==145))
					{
						int LA188_3 = input.LA(3);

						if ((LA188_3==DOT||LA188_3==SEMI||LA188_3==62||LA188_3==85||LA188_3==91||LA188_3==101))
						{
							alt188=1;
						}


					}
					else if ((LA188_1==IDENTIFIER||(LA188_1>=ELIF && LA188_1<=UNDEF)||LA188_1==65||(LA188_1>=132 && LA188_1<=133)||(LA188_1>=135 && LA188_1<=144)||(LA188_1>=146 && LA188_1<=148)||(LA188_1>=150 && LA188_1<=152)||LA188_1==154||(LA188_1>=156 && LA188_1<=159)||LA188_1==170||(LA188_1>=177 && LA188_1<=178)||LA188_1==195||LA188_1==202))
					{
						alt188=1;
					}


				}


				} finally { DebugExitDecision(188); }
				switch ( alt188 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:682:24: ',' secondary_constraint
					{
					DebugLocation(682, 24);
					char_literal664=(IToken)Match(input,91,Follow._91_in_secondary_constraint_list5284); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal664_tree = (object)adaptor.Create(char_literal664);
					adaptor.AddChild(root_0, char_literal664_tree);
					}
					DebugLocation(682, 28);
					PushFollow(Follow._secondary_constraint_in_secondary_constraint_list5286);
					secondary_constraint665=secondary_constraint();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, secondary_constraint665.Tree);

					}
					break;

				default:
					goto loop188;
				}
			}

			loop188:
				;

			} finally { DebugExitSubRule(188); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("secondary_constraint_list", 192);
			LeaveRule("secondary_constraint_list", 192);
			Leave_secondary_constraint_list();
			if (state.backtracking > 0) { Memoize(input, 192, secondary_constraint_list_StartIndex); }
		}
		DebugLocation(682, 50);
		} finally { DebugExitRule(GrammarFileName, "secondary_constraint_list"); }
		return retval;

	}
	// $ANTLR end "secondary_constraint_list"

	public class secondary_constraint_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_secondary_constraint();
	partial void Leave_secondary_constraint();

	// $ANTLR start "secondary_constraint"
	// cs.g:683:8: public secondary_constraint : type_name ;
	[GrammarRule("secondary_constraint")]
	public csParser.secondary_constraint_return secondary_constraint()
	{
		Enter_secondary_constraint();
		EnterRule("secondary_constraint", 193);
		TraceIn("secondary_constraint", 193);
		csParser.secondary_constraint_return retval = new csParser.secondary_constraint_return();
		retval.Start = (IToken)input.LT(1);
		int secondary_constraint_StartIndex = input.Index;
		object root_0 = null;

		csParser.type_name_return type_name666 = default(csParser.type_name_return);


		try { DebugEnterRule(GrammarFileName, "secondary_constraint");
		DebugLocation(683, 11);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 193)) { return retval; }
			// cs.g:683:28: ( type_name )
			DebugEnterAlt(1);
			// cs.g:684:2: type_name
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(684, 2);
			PushFollow(Follow._type_name_in_secondary_constraint5298);
			type_name666=type_name();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name666.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("secondary_constraint", 193);
			LeaveRule("secondary_constraint", 193);
			Leave_secondary_constraint();
			if (state.backtracking > 0) { Memoize(input, 193, secondary_constraint_StartIndex); }
		}
		DebugLocation(684, 11);
		} finally { DebugExitRule(GrammarFileName, "secondary_constraint"); }
		return retval;

	}
	// $ANTLR end "secondary_constraint"

	public class type_variable_name_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_type_variable_name();
	partial void Leave_type_variable_name();

	// $ANTLR start "type_variable_name"
	// cs.g:685:8: public type_variable_name : identifier ;
	[GrammarRule("type_variable_name")]
	public csParser.type_variable_name_return type_variable_name()
	{
		Enter_type_variable_name();
		EnterRule("type_variable_name", 194);
		TraceIn("type_variable_name", 194);
		csParser.type_variable_name_return retval = new csParser.type_variable_name_return();
		retval.Start = (IToken)input.LT(1);
		int type_variable_name_StartIndex = input.Index;
		object root_0 = null;

		csParser.identifier_return identifier667 = default(csParser.identifier_return);


		try { DebugEnterRule(GrammarFileName, "type_variable_name");
		DebugLocation(685, 12);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 194)) { return retval; }
			// cs.g:685:26: ( identifier )
			DebugEnterAlt(1);
			// cs.g:686:2: identifier
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(686, 2);
			PushFollow(Follow._identifier_in_type_variable_name5310);
			identifier667=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier667.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("type_variable_name", 194);
			LeaveRule("type_variable_name", 194);
			Leave_type_variable_name();
			if (state.backtracking > 0) { Memoize(input, 194, type_variable_name_StartIndex); }
		}
		DebugLocation(686, 12);
		} finally { DebugExitRule(GrammarFileName, "type_variable_name"); }
		return retval;

	}
	// $ANTLR end "type_variable_name"

	public class constructor_constraint_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_constructor_constraint();
	partial void Leave_constructor_constraint();

	// $ANTLR start "constructor_constraint"
	// cs.g:687:8: public constructor_constraint : 'new' '(' ')' ;
	[GrammarRule("constructor_constraint")]
	public csParser.constructor_constraint_return constructor_constraint()
	{
		Enter_constructor_constraint();
		EnterRule("constructor_constraint", 195);
		TraceIn("constructor_constraint", 195);
		csParser.constructor_constraint_return retval = new csParser.constructor_constraint_return();
		retval.Start = (IToken)input.LT(1);
		int constructor_constraint_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal668=null;
		IToken char_literal669=null;
		IToken char_literal670=null;

		object string_literal668_tree=null;
		object char_literal669_tree=null;
		object char_literal670_tree=null;

		try { DebugEnterRule(GrammarFileName, "constructor_constraint");
		DebugLocation(687, 19);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 195)) { return retval; }
			// cs.g:687:30: ( 'new' '(' ')' )
			DebugEnterAlt(1);
			// cs.g:688:2: 'new' '(' ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(688, 2);
			string_literal668=(IToken)Match(input,68,Follow._68_in_constructor_constraint5320); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal668_tree = (object)adaptor.Create(string_literal668);
			adaptor.AddChild(root_0, string_literal668_tree);
			}
			DebugLocation(688, 10);
			char_literal669=(IToken)Match(input,90,Follow._90_in_constructor_constraint5324); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal669_tree = (object)adaptor.Create(char_literal669);
			adaptor.AddChild(root_0, char_literal669_tree);
			}
			DebugLocation(688, 16);
			char_literal670=(IToken)Match(input,RPAREN,Follow._RPAREN_in_constructor_constraint5328); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal670_tree = (object)adaptor.Create(char_literal670);
			adaptor.AddChild(root_0, char_literal670_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("constructor_constraint", 195);
			LeaveRule("constructor_constraint", 195);
			Leave_constructor_constraint();
			if (state.backtracking > 0) { Memoize(input, 195, constructor_constraint_StartIndex); }
		}
		DebugLocation(688, 19);
		} finally { DebugExitRule(GrammarFileName, "constructor_constraint"); }
		return retval;

	}
	// $ANTLR end "constructor_constraint"

	public class return_type_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_return_type();
	partial void Leave_return_type();

	// $ANTLR start "return_type"
	// cs.g:689:8: public return_type : ( type | 'void' );
	[GrammarRule("return_type")]
	public csParser.return_type_return return_type()
	{
		Enter_return_type();
		EnterRule("return_type", 196);
		TraceIn("return_type", 196);
		csParser.return_type_return retval = new csParser.return_type_return();
		retval.Start = (IToken)input.LT(1);
		int return_type_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal672=null;
		csParser.type_return type671 = default(csParser.type_return);

		object string_literal672_tree=null;

		try { DebugEnterRule(GrammarFileName, "return_type");
		DebugLocation(689, 10);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 196)) { return retval; }
			// cs.g:689:19: ( type | 'void' )
			int alt189=2;
			try { DebugEnterDecision(189, decisionCanBacktrack[189]);
			int LA189_0 = input.LA(1);

			if ((LA189_0==IDENTIFIER||(LA189_0>=ELIF && LA189_0<=UNDEF)||LA189_0==65||(LA189_0>=132 && LA189_0<=133)||(LA189_0>=135 && LA189_0<=148)||(LA189_0>=150 && LA189_0<=152)||LA189_0==154||(LA189_0>=156 && LA189_0<=168)||LA189_0==170||(LA189_0>=177 && LA189_0<=178)||(LA189_0>=195 && LA189_0<=202)))
			{
				alt189=1;
			}
			else if ((LA189_0==82))
			{
				int LA189_2 = input.LA(2);

				if ((LA189_2==102))
				{
					alt189=1;
				}
				else if ((LA189_2==IDENTIFIER||(LA189_2>=ELIF && LA189_2<=UNDEF)||LA189_2==65||(LA189_2>=132 && LA189_2<=133)||(LA189_2>=135 && LA189_2<=148)||(LA189_2>=150 && LA189_2<=152)||LA189_2==154||(LA189_2>=156 && LA189_2<=159)||LA189_2==170||(LA189_2>=177 && LA189_2<=178)||LA189_2==195||LA189_2==202))
				{
					alt189=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 189, 2, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 189, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(189); }
			switch (alt189)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:690:2: type
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(690, 2);
				PushFollow(Follow._type_in_return_type5338);
				type671=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type671.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:691:5: 'void'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(691, 5);
				string_literal672=(IToken)Match(input,82,Follow._82_in_return_type5344); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal672_tree = (object)adaptor.Create(string_literal672);
				adaptor.AddChild(root_0, string_literal672_tree);
				}

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("return_type", 196);
			LeaveRule("return_type", 196);
			Leave_return_type();
			if (state.backtracking > 0) { Memoize(input, 196, return_type_StartIndex); }
		}
		DebugLocation(691, 10);
		} finally { DebugExitRule(GrammarFileName, "return_type"); }
		return retval;

	}
	// $ANTLR end "return_type"

	public class formal_parameter_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_formal_parameter_list();
	partial void Leave_formal_parameter_list();

	// $ANTLR start "formal_parameter_list"
	// cs.g:692:8: public formal_parameter_list : formal_parameter ( ',' formal_parameter )* ;
	[GrammarRule("formal_parameter_list")]
	public csParser.formal_parameter_list_return formal_parameter_list()
	{
		Enter_formal_parameter_list();
		EnterRule("formal_parameter_list", 197);
		TraceIn("formal_parameter_list", 197);
		csParser.formal_parameter_list_return retval = new csParser.formal_parameter_list_return();
		retval.Start = (IToken)input.LT(1);
		int formal_parameter_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal674=null;
		csParser.formal_parameter_return formal_parameter673 = default(csParser.formal_parameter_return);
		csParser.formal_parameter_return formal_parameter675 = default(csParser.formal_parameter_return);

		object char_literal674_tree=null;

		try { DebugEnterRule(GrammarFileName, "formal_parameter_list");
		DebugLocation(692, 42);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 197)) { return retval; }
			// cs.g:692:29: ( formal_parameter ( ',' formal_parameter )* )
			DebugEnterAlt(1);
			// cs.g:693:2: formal_parameter ( ',' formal_parameter )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(693, 2);
			PushFollow(Follow._formal_parameter_in_formal_parameter_list5353);
			formal_parameter673=formal_parameter();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter673.Tree);
			DebugLocation(693, 19);
			// cs.g:693:19: ( ',' formal_parameter )*
			try { DebugEnterSubRule(190);
			while (true)
			{
				int alt190=2;
				try { DebugEnterDecision(190, decisionCanBacktrack[190]);
				int LA190_0 = input.LA(1);

				if ((LA190_0==91))
				{
					alt190=1;
				}


				} finally { DebugExitDecision(190); }
				switch ( alt190 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:693:20: ',' formal_parameter
					{
					DebugLocation(693, 20);
					char_literal674=(IToken)Match(input,91,Follow._91_in_formal_parameter_list5356); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal674_tree = (object)adaptor.Create(char_literal674);
					adaptor.AddChild(root_0, char_literal674_tree);
					}
					DebugLocation(693, 24);
					PushFollow(Follow._formal_parameter_in_formal_parameter_list5358);
					formal_parameter675=formal_parameter();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter675.Tree);

					}
					break;

				default:
					goto loop190;
				}
			}

			loop190:
				;

			} finally { DebugExitSubRule(190); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("formal_parameter_list", 197);
			LeaveRule("formal_parameter_list", 197);
			Leave_formal_parameter_list();
			if (state.backtracking > 0) { Memoize(input, 197, formal_parameter_list_StartIndex); }
		}
		DebugLocation(693, 42);
		} finally { DebugExitRule(GrammarFileName, "formal_parameter_list"); }
		return retval;

	}
	// $ANTLR end "formal_parameter_list"

	public class formal_parameter_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_formal_parameter();
	partial void Leave_formal_parameter();

	// $ANTLR start "formal_parameter"
	// cs.g:694:8: public formal_parameter : ( ( attributes )? ( fixed_parameter | parameter_array ) | '__arglist' );
	[GrammarRule("formal_parameter")]
	public csParser.formal_parameter_return formal_parameter()
	{
		Enter_formal_parameter();
		EnterRule("formal_parameter", 198);
		TraceIn("formal_parameter", 198);
		csParser.formal_parameter_return retval = new csParser.formal_parameter_return();
		retval.Start = (IToken)input.LT(1);
		int formal_parameter_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal679=null;
		csParser.attributes_return attributes676 = default(csParser.attributes_return);
		csParser.fixed_parameter_return fixed_parameter677 = default(csParser.fixed_parameter_return);
		csParser.parameter_array_return parameter_array678 = default(csParser.parameter_array_return);

		object string_literal679_tree=null;

		try { DebugEnterRule(GrammarFileName, "formal_parameter");
		DebugLocation(694, 14);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 198)) { return retval; }
			// cs.g:694:24: ( ( attributes )? ( fixed_parameter | parameter_array ) | '__arglist' )
			int alt193=2;
			try { DebugEnterDecision(193, decisionCanBacktrack[193]);
			int LA193_0 = input.LA(1);

			if ((LA193_0==IDENTIFIER||(LA193_0>=ELIF && LA193_0<=UNDEF)||LA193_0==65||(LA193_0>=82 && LA193_0<=83)||LA193_0==88||(LA193_0>=93 && LA193_0<=94)||(LA193_0>=132 && LA193_0<=133)||(LA193_0>=135 && LA193_0<=148)||(LA193_0>=150 && LA193_0<=152)||LA193_0==154||(LA193_0>=156 && LA193_0<=168)||LA193_0==171||(LA193_0>=177 && LA193_0<=178)||(LA193_0>=195 && LA193_0<=202)))
			{
				alt193=1;
			}
			else if ((LA193_0==170))
			{
				int LA193_2 = input.LA(2);

				if ((LA193_2==IDENTIFIER||LA193_2==DOT||(LA193_2>=ELIF && LA193_2<=UNDEF)||LA193_2==65||LA193_2==85||LA193_2==88||(LA193_2>=101 && LA193_2<=103)||(LA193_2>=132 && LA193_2<=133)||(LA193_2>=135 && LA193_2<=148)||(LA193_2>=150 && LA193_2<=152)||LA193_2==154||(LA193_2>=156 && LA193_2<=159)||LA193_2==170||(LA193_2>=177 && LA193_2<=178)||LA193_2==195||LA193_2==202))
				{
					alt193=1;
				}
				else if ((LA193_2==RPAREN||LA193_2==89||LA193_2==91))
				{
					alt193=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 193, 2, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 193, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(193); }
			switch (alt193)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:695:2: ( attributes )? ( fixed_parameter | parameter_array )
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(695, 2);
				// cs.g:695:2: ( attributes )?
				int alt191=2;
				try { DebugEnterSubRule(191);
				try { DebugEnterDecision(191, decisionCanBacktrack[191]);
				int LA191_0 = input.LA(1);

				if ((LA191_0==88))
				{
					alt191=1;
				}
				} finally { DebugExitDecision(191); }
				switch (alt191)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:695:2: attributes
					{
					DebugLocation(695, 2);
					PushFollow(Follow._attributes_in_formal_parameter5370);
					attributes676=attributes();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes676.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(191); }

				DebugLocation(695, 16);
				// cs.g:695:16: ( fixed_parameter | parameter_array )
				int alt192=2;
				try { DebugEnterSubRule(192);
				try { DebugEnterDecision(192, decisionCanBacktrack[192]);
				int LA192_0 = input.LA(1);

				if ((LA192_0==IDENTIFIER||(LA192_0>=ELIF && LA192_0<=UNDEF)||LA192_0==65||(LA192_0>=82 && LA192_0<=83)||(LA192_0>=93 && LA192_0<=94)||(LA192_0>=132 && LA192_0<=133)||(LA192_0>=135 && LA192_0<=148)||(LA192_0>=150 && LA192_0<=152)||LA192_0==154||(LA192_0>=156 && LA192_0<=168)||LA192_0==170||(LA192_0>=177 && LA192_0<=178)||(LA192_0>=195 && LA192_0<=202)))
				{
					alt192=1;
				}
				else if ((LA192_0==171))
				{
					alt192=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 192, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				} finally { DebugExitDecision(192); }
				switch (alt192)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:695:17: fixed_parameter
					{
					DebugLocation(695, 17);
					PushFollow(Follow._fixed_parameter_in_formal_parameter5376);
					fixed_parameter677=fixed_parameter();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_parameter677.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:695:35: parameter_array
					{
					DebugLocation(695, 35);
					PushFollow(Follow._parameter_array_in_formal_parameter5380);
					parameter_array678=parameter_array();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, parameter_array678.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(192); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:696:4: '__arglist'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(696, 4);
				string_literal679=(IToken)Match(input,170,Follow._170_in_formal_parameter5387); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal679_tree = (object)adaptor.Create(string_literal679);
				adaptor.AddChild(root_0, string_literal679_tree);
				}

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("formal_parameter", 198);
			LeaveRule("formal_parameter", 198);
			Leave_formal_parameter();
			if (state.backtracking > 0) { Memoize(input, 198, formal_parameter_StartIndex); }
		}
		DebugLocation(696, 14);
		} finally { DebugExitRule(GrammarFileName, "formal_parameter"); }
		return retval;

	}
	// $ANTLR end "formal_parameter"

	public class fixed_parameters_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_fixed_parameters();
	partial void Leave_fixed_parameters();

	// $ANTLR start "fixed_parameters"
	// cs.g:697:8: public fixed_parameters : fixed_parameter ( ',' fixed_parameter )* ;
	[GrammarRule("fixed_parameters")]
	public csParser.fixed_parameters_return fixed_parameters()
	{
		Enter_fixed_parameters();
		EnterRule("fixed_parameters", 199);
		TraceIn("fixed_parameters", 199);
		csParser.fixed_parameters_return retval = new csParser.fixed_parameters_return();
		retval.Start = (IToken)input.LT(1);
		int fixed_parameters_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal681=null;
		csParser.fixed_parameter_return fixed_parameter680 = default(csParser.fixed_parameter_return);
		csParser.fixed_parameter_return fixed_parameter682 = default(csParser.fixed_parameter_return);

		object char_literal681_tree=null;

		try { DebugEnterRule(GrammarFileName, "fixed_parameters");
		DebugLocation(697, 44);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 199)) { return retval; }
			// cs.g:697:24: ( fixed_parameter ( ',' fixed_parameter )* )
			DebugEnterAlt(1);
			// cs.g:698:2: fixed_parameter ( ',' fixed_parameter )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(698, 2);
			PushFollow(Follow._fixed_parameter_in_fixed_parameters5397);
			fixed_parameter680=fixed_parameter();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_parameter680.Tree);
			DebugLocation(698, 20);
			// cs.g:698:20: ( ',' fixed_parameter )*
			try { DebugEnterSubRule(194);
			while (true)
			{
				int alt194=2;
				try { DebugEnterDecision(194, decisionCanBacktrack[194]);
				int LA194_0 = input.LA(1);

				if ((LA194_0==91))
				{
					alt194=1;
				}


				} finally { DebugExitDecision(194); }
				switch ( alt194 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:698:21: ',' fixed_parameter
					{
					DebugLocation(698, 21);
					char_literal681=(IToken)Match(input,91,Follow._91_in_fixed_parameters5402); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal681_tree = (object)adaptor.Create(char_literal681);
					adaptor.AddChild(root_0, char_literal681_tree);
					}
					DebugLocation(698, 27);
					PushFollow(Follow._fixed_parameter_in_fixed_parameters5406);
					fixed_parameter682=fixed_parameter();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_parameter682.Tree);

					}
					break;

				default:
					goto loop194;
				}
			}

			loop194:
				;

			} finally { DebugExitSubRule(194); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("fixed_parameters", 199);
			LeaveRule("fixed_parameters", 199);
			Leave_fixed_parameters();
			if (state.backtracking > 0) { Memoize(input, 199, fixed_parameters_StartIndex); }
		}
		DebugLocation(698, 44);
		} finally { DebugExitRule(GrammarFileName, "fixed_parameters"); }
		return retval;

	}
	// $ANTLR end "fixed_parameters"

	public class fixed_parameter_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_fixed_parameter();
	partial void Leave_fixed_parameter();

	// $ANTLR start "fixed_parameter"
	// cs.g:700:8: public fixed_parameter : ( parameter_modifier )? type identifier ( default_argument )? ;
	[GrammarRule("fixed_parameter")]
	public csParser.fixed_parameter_return fixed_parameter()
	{
		Enter_fixed_parameter();
		EnterRule("fixed_parameter", 200);
		TraceIn("fixed_parameter", 200);
		csParser.fixed_parameter_return retval = new csParser.fixed_parameter_return();
		retval.Start = (IToken)input.LT(1);
		int fixed_parameter_StartIndex = input.Index;
		object root_0 = null;

		csParser.parameter_modifier_return parameter_modifier683 = default(csParser.parameter_modifier_return);
		csParser.type_return type684 = default(csParser.type_return);
		csParser.identifier_return identifier685 = default(csParser.identifier_return);
		csParser.default_argument_return default_argument686 = default(csParser.default_argument_return);


		try { DebugEnterRule(GrammarFileName, "fixed_parameter");
		DebugLocation(700, 61);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 200)) { return retval; }
			// cs.g:700:23: ( ( parameter_modifier )? type identifier ( default_argument )? )
			DebugEnterAlt(1);
			// cs.g:701:2: ( parameter_modifier )? type identifier ( default_argument )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(701, 2);
			// cs.g:701:2: ( parameter_modifier )?
			int alt195=2;
			try { DebugEnterSubRule(195);
			try { DebugEnterDecision(195, decisionCanBacktrack[195]);
			int LA195_0 = input.LA(1);

			if ((LA195_0==83||(LA195_0>=93 && LA195_0<=94)))
			{
				alt195=1;
			}
			} finally { DebugExitDecision(195); }
			switch (alt195)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:701:2: parameter_modifier
				{
				DebugLocation(701, 2);
				PushFollow(Follow._parameter_modifier_in_fixed_parameter5419);
				parameter_modifier683=parameter_modifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, parameter_modifier683.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(195); }

			DebugLocation(701, 24);
			PushFollow(Follow._type_in_fixed_parameter5424);
			type684=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type684.Tree);
			DebugLocation(701, 31);
			PushFollow(Follow._identifier_in_fixed_parameter5428);
			identifier685=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier685.Tree);
			DebugLocation(701, 44);
			// cs.g:701:44: ( default_argument )?
			int alt196=2;
			try { DebugEnterSubRule(196);
			try { DebugEnterDecision(196, decisionCanBacktrack[196]);
			int LA196_0 = input.LA(1);

			if ((LA196_0==66))
			{
				alt196=1;
			}
			} finally { DebugExitDecision(196); }
			switch (alt196)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:701:44: default_argument
				{
				DebugLocation(701, 44);
				PushFollow(Follow._default_argument_in_fixed_parameter5432);
				default_argument686=default_argument();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, default_argument686.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(196); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("fixed_parameter", 200);
			LeaveRule("fixed_parameter", 200);
			Leave_fixed_parameter();
			if (state.backtracking > 0) { Memoize(input, 200, fixed_parameter_StartIndex); }
		}
		DebugLocation(701, 61);
		} finally { DebugExitRule(GrammarFileName, "fixed_parameter"); }
		return retval;

	}
	// $ANTLR end "fixed_parameter"

	public class default_argument_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_default_argument();
	partial void Leave_default_argument();

	// $ANTLR start "default_argument"
	// cs.g:703:8: public default_argument : '=' expression ;
	[GrammarRule("default_argument")]
	public csParser.default_argument_return default_argument()
	{
		Enter_default_argument();
		EnterRule("default_argument", 201);
		TraceIn("default_argument", 201);
		csParser.default_argument_return retval = new csParser.default_argument_return();
		retval.Start = (IToken)input.LT(1);
		int default_argument_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal687=null;
		csParser.expression_return expression688 = default(csParser.expression_return);

		object char_literal687_tree=null;

		try { DebugEnterRule(GrammarFileName, "default_argument");
		DebugLocation(703, 15);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 201)) { return retval; }
			// cs.g:703:24: ( '=' expression )
			DebugEnterAlt(1);
			// cs.g:704:2: '=' expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(704, 2);
			char_literal687=(IToken)Match(input,66,Follow._66_in_default_argument5444); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal687_tree = (object)adaptor.Create(char_literal687);
			adaptor.AddChild(root_0, char_literal687_tree);
			}
			DebugLocation(704, 6);
			PushFollow(Follow._expression_in_default_argument5446);
			expression688=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression688.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("default_argument", 201);
			LeaveRule("default_argument", 201);
			Leave_default_argument();
			if (state.backtracking > 0) { Memoize(input, 201, default_argument_StartIndex); }
		}
		DebugLocation(704, 15);
		} finally { DebugExitRule(GrammarFileName, "default_argument"); }
		return retval;

	}
	// $ANTLR end "default_argument"

	public class parameter_modifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_parameter_modifier();
	partial void Leave_parameter_modifier();

	// $ANTLR start "parameter_modifier"
	// cs.g:705:8: public parameter_modifier : ( 'ref' | 'out' | 'this' );
	[GrammarRule("parameter_modifier")]
	public csParser.parameter_modifier_return parameter_modifier()
	{
		Enter_parameter_modifier();
		EnterRule("parameter_modifier", 202);
		TraceIn("parameter_modifier", 202);
		csParser.parameter_modifier_return retval = new csParser.parameter_modifier_return();
		retval.Start = (IToken)input.LT(1);
		int parameter_modifier_StartIndex = input.Index;
		object root_0 = null;

		IToken set689=null;

		object set689_tree=null;

		try { DebugEnterRule(GrammarFileName, "parameter_modifier");
		DebugLocation(705, 24);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 202)) { return retval; }
			// cs.g:705:26: ( 'ref' | 'out' | 'this' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(705, 26);
			set689=(IToken)input.LT(1);
			if (input.LA(1)==83||(input.LA(1)>=93 && input.LA(1)<=94))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set689));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("parameter_modifier", 202);
			LeaveRule("parameter_modifier", 202);
			Leave_parameter_modifier();
			if (state.backtracking > 0) { Memoize(input, 202, parameter_modifier_StartIndex); }
		}
		DebugLocation(706, 24);
		} finally { DebugExitRule(GrammarFileName, "parameter_modifier"); }
		return retval;

	}
	// $ANTLR end "parameter_modifier"

	public class parameter_array_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_parameter_array();
	partial void Leave_parameter_array();

	// $ANTLR start "parameter_array"
	// cs.g:707:8: public parameter_array : 'params' type identifier ;
	[GrammarRule("parameter_array")]
	public csParser.parameter_array_return parameter_array()
	{
		Enter_parameter_array();
		EnterRule("parameter_array", 203);
		TraceIn("parameter_array", 203);
		csParser.parameter_array_return retval = new csParser.parameter_array_return();
		retval.Start = (IToken)input.LT(1);
		int parameter_array_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal690=null;
		csParser.type_return type691 = default(csParser.type_return);
		csParser.identifier_return identifier692 = default(csParser.identifier_return);

		object string_literal690_tree=null;

		try { DebugEnterRule(GrammarFileName, "parameter_array");
		DebugLocation(707, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 203)) { return retval; }
			// cs.g:707:23: ( 'params' type identifier )
			DebugEnterAlt(1);
			// cs.g:708:2: 'params' type identifier
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(708, 2);
			string_literal690=(IToken)Match(input,171,Follow._171_in_parameter_array5473); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal690_tree = (object)adaptor.Create(string_literal690);
			adaptor.AddChild(root_0, string_literal690_tree);
			}
			DebugLocation(708, 13);
			PushFollow(Follow._type_in_parameter_array5477);
			type691=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type691.Tree);
			DebugLocation(708, 20);
			PushFollow(Follow._identifier_in_parameter_array5481);
			identifier692=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier692.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("parameter_array", 203);
			LeaveRule("parameter_array", 203);
			Leave_parameter_array();
			if (state.backtracking > 0) { Memoize(input, 203, parameter_array_StartIndex); }
		}
		DebugLocation(708, 30);
		} finally { DebugExitRule(GrammarFileName, "parameter_array"); }
		return retval;

	}
	// $ANTLR end "parameter_array"

	public class interface_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_declaration();
	partial void Leave_interface_declaration();

	// $ANTLR start "interface_declaration"
	// cs.g:711:8: public interface_declaration : 'interface' identifier ( variant_generic_parameter_list )? ( interface_base )? ( type_parameter_constraints_clauses )? interface_body ( ';' )? ;
	[GrammarRule("interface_declaration")]
	public csParser.interface_declaration_return interface_declaration()
	{
		Enter_interface_declaration();
		EnterRule("interface_declaration", 204);
		TraceIn("interface_declaration", 204);
		csParser.interface_declaration_return retval = new csParser.interface_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int interface_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal693=null;
		IToken char_literal699=null;
		csParser.identifier_return identifier694 = default(csParser.identifier_return);
		csParser.variant_generic_parameter_list_return variant_generic_parameter_list695 = default(csParser.variant_generic_parameter_list_return);
		csParser.interface_base_return interface_base696 = default(csParser.interface_base_return);
		csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses697 = default(csParser.type_parameter_constraints_clauses_return);
		csParser.interface_body_return interface_body698 = default(csParser.interface_body_return);

		object string_literal693_tree=null;
		object char_literal699_tree=null;

		try { DebugEnterRule(GrammarFileName, "interface_declaration");
		DebugLocation(711, 83);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 204)) { return retval; }
			// cs.g:711:29: ( 'interface' identifier ( variant_generic_parameter_list )? ( interface_base )? ( type_parameter_constraints_clauses )? interface_body ( ';' )? )
			DebugEnterAlt(1);
			// cs.g:712:2: 'interface' identifier ( variant_generic_parameter_list )? ( interface_base )? ( type_parameter_constraints_clauses )? interface_body ( ';' )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(712, 2);
			string_literal693=(IToken)Match(input,172,Follow._172_in_interface_declaration5493); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal693_tree = (object)adaptor.Create(string_literal693);
			adaptor.AddChild(root_0, string_literal693_tree);
			}
			DebugLocation(712, 16);
			PushFollow(Follow._identifier_in_interface_declaration5497);
			identifier694=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier694.Tree);
			DebugLocation(712, 29);
			// cs.g:712:29: ( variant_generic_parameter_list )?
			int alt197=2;
			try { DebugEnterSubRule(197);
			try { DebugEnterDecision(197, decisionCanBacktrack[197]);
			int LA197_0 = input.LA(1);

			if ((LA197_0==101))
			{
				alt197=1;
			}
			} finally { DebugExitDecision(197); }
			switch (alt197)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:712:29: variant_generic_parameter_list
				{
				DebugLocation(712, 29);
				PushFollow(Follow._variant_generic_parameter_list_in_interface_declaration5501);
				variant_generic_parameter_list695=variant_generic_parameter_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variant_generic_parameter_list695.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(197); }

			DebugLocation(713, 6);
			// cs.g:713:6: ( interface_base )?
			int alt198=2;
			try { DebugEnterSubRule(198);
			try { DebugEnterDecision(198, decisionCanBacktrack[198]);
			int LA198_0 = input.LA(1);

			if ((LA198_0==92))
			{
				alt198=1;
			}
			} finally { DebugExitDecision(198); }
			switch (alt198)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:713:6: interface_base
				{
				DebugLocation(713, 6);
				PushFollow(Follow._interface_base_in_interface_declaration5510);
				interface_base696=interface_base();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_base696.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(198); }

			DebugLocation(713, 24);
			// cs.g:713:24: ( type_parameter_constraints_clauses )?
			int alt199=2;
			try { DebugEnterSubRule(199);
			try { DebugEnterDecision(199, decisionCanBacktrack[199]);
			int LA199_0 = input.LA(1);

			if ((LA199_0==145))
			{
				alt199=1;
			}
			} finally { DebugExitDecision(199); }
			switch (alt199)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:713:24: type_parameter_constraints_clauses
				{
				DebugLocation(713, 24);
				PushFollow(Follow._type_parameter_constraints_clauses_in_interface_declaration5515);
				type_parameter_constraints_clauses697=type_parameter_constraints_clauses();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses697.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(199); }

			DebugLocation(713, 62);
			PushFollow(Follow._interface_body_in_interface_declaration5520);
			interface_body698=interface_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_body698.Tree);
			DebugLocation(713, 79);
			// cs.g:713:79: ( ';' )?
			int alt200=2;
			try { DebugEnterSubRule(200);
			try { DebugEnterDecision(200, decisionCanBacktrack[200]);
			int LA200_0 = input.LA(1);

			if ((LA200_0==SEMI))
			{
				alt200=1;
			}
			} finally { DebugExitDecision(200); }
			switch (alt200)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:713:79: ';'
				{
				DebugLocation(713, 79);
				char_literal699=(IToken)Match(input,SEMI,Follow._SEMI_in_interface_declaration5524); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal699_tree = (object)adaptor.Create(char_literal699);
				adaptor.AddChild(root_0, char_literal699_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(200); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_declaration", 204);
			LeaveRule("interface_declaration", 204);
			Leave_interface_declaration();
			if (state.backtracking > 0) { Memoize(input, 204, interface_declaration_StartIndex); }
		}
		DebugLocation(713, 83);
		} finally { DebugExitRule(GrammarFileName, "interface_declaration"); }
		return retval;

	}
	// $ANTLR end "interface_declaration"

	public class interface_modifiers_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_modifiers();
	partial void Leave_interface_modifiers();

	// $ANTLR start "interface_modifiers"
	// cs.g:714:8: public interface_modifiers : ( modifier )+ ;
	[GrammarRule("interface_modifiers")]
	public csParser.interface_modifiers_return interface_modifiers()
	{
		Enter_interface_modifiers();
		EnterRule("interface_modifiers", 205);
		TraceIn("interface_modifiers", 205);
		csParser.interface_modifiers_return retval = new csParser.interface_modifiers_return();
		retval.Start = (IToken)input.LT(1);
		int interface_modifiers_StartIndex = input.Index;
		object root_0 = null;

		csParser.modifier_return modifier700 = default(csParser.modifier_return);


		try { DebugEnterRule(GrammarFileName, "interface_modifiers");
		DebugLocation(714, 11);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 205)) { return retval; }
			// cs.g:714:27: ( ( modifier )+ )
			DebugEnterAlt(1);
			// cs.g:715:2: ( modifier )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(715, 2);
			// cs.g:715:2: ( modifier )+
			int cnt201=0;
			try { DebugEnterSubRule(201);
			while (true)
			{
				int alt201=2;
				try { DebugEnterDecision(201, decisionCanBacktrack[201]);
				int LA201_0 = input.LA(1);

				if ((LA201_0==64||(LA201_0>=68 && LA201_0<=80)))
				{
					alt201=1;
				}


				} finally { DebugExitDecision(201); }
				switch (alt201)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:715:2: modifier
					{
					DebugLocation(715, 2);
					PushFollow(Follow._modifier_in_interface_modifiers5536);
					modifier700=modifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifier700.Tree);

					}
					break;

				default:
					if (cnt201 >= 1)
						goto loop201;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee201 = new EarlyExitException( 201, input );
					DebugRecognitionException(eee201);
					throw eee201;
				}
				cnt201++;
			}
			loop201:
				;

			} finally { DebugExitSubRule(201); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_modifiers", 205);
			LeaveRule("interface_modifiers", 205);
			Leave_interface_modifiers();
			if (state.backtracking > 0) { Memoize(input, 205, interface_modifiers_StartIndex); }
		}
		DebugLocation(715, 11);
		} finally { DebugExitRule(GrammarFileName, "interface_modifiers"); }
		return retval;

	}
	// $ANTLR end "interface_modifiers"

	public class interface_base_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_base();
	partial void Leave_interface_base();

	// $ANTLR start "interface_base"
	// cs.g:716:8: public interface_base : ':' interface_type_list ;
	[GrammarRule("interface_base")]
	public csParser.interface_base_return interface_base()
	{
		Enter_interface_base();
		EnterRule("interface_base", 206);
		TraceIn("interface_base", 206);
		csParser.interface_base_return retval = new csParser.interface_base_return();
		retval.Start = (IToken)input.LT(1);
		int interface_base_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal701=null;
		csParser.interface_type_list_return interface_type_list702 = default(csParser.interface_type_list_return);

		object char_literal701_tree=null;

		try { DebugEnterRule(GrammarFileName, "interface_base");
		DebugLocation(716, 28);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 206)) { return retval; }
			// cs.g:716:22: ( ':' interface_type_list )
			DebugEnterAlt(1);
			// cs.g:717:5: ':' interface_type_list
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(717, 5);
			char_literal701=(IToken)Match(input,92,Follow._92_in_interface_base5551); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal701_tree = (object)adaptor.Create(char_literal701);
			adaptor.AddChild(root_0, char_literal701_tree);
			}
			DebugLocation(717, 9);
			PushFollow(Follow._interface_type_list_in_interface_base5553);
			interface_type_list702=interface_type_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_type_list702.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_base", 206);
			LeaveRule("interface_base", 206);
			Leave_interface_base();
			if (state.backtracking > 0) { Memoize(input, 206, interface_base_StartIndex); }
		}
		DebugLocation(717, 28);
		} finally { DebugExitRule(GrammarFileName, "interface_base"); }
		return retval;

	}
	// $ANTLR end "interface_base"

	public class interface_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_body();
	partial void Leave_interface_body();

	// $ANTLR start "interface_body"
	// cs.g:718:8: public interface_body : '{' ( interface_member_declarations )? '}' ;
	[GrammarRule("interface_body")]
	public csParser.interface_body_return interface_body()
	{
		Enter_interface_body();
		EnterRule("interface_body", 207);
		TraceIn("interface_body", 207);
		csParser.interface_body_return retval = new csParser.interface_body_return();
		retval.Start = (IToken)input.LT(1);
		int interface_body_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal703=null;
		IToken char_literal705=null;
		csParser.interface_member_declarations_return interface_member_declarations704 = default(csParser.interface_member_declarations_return);

		object char_literal703_tree=null;
		object char_literal705_tree=null;

		try { DebugEnterRule(GrammarFileName, "interface_body");
		DebugLocation(718, 44);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 207)) { return retval; }
			// cs.g:718:22: ( '{' ( interface_member_declarations )? '}' )
			DebugEnterAlt(1);
			// cs.g:719:2: '{' ( interface_member_declarations )? '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(719, 2);
			char_literal703=(IToken)Match(input,62,Follow._62_in_interface_body5563); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal703_tree = (object)adaptor.Create(char_literal703);
			adaptor.AddChild(root_0, char_literal703_tree);
			}
			DebugLocation(719, 8);
			// cs.g:719:8: ( interface_member_declarations )?
			int alt202=2;
			try { DebugEnterSubRule(202);
			try { DebugEnterDecision(202, decisionCanBacktrack[202]);
			int LA202_0 = input.LA(1);

			if ((LA202_0==IDENTIFIER||(LA202_0>=ELIF && LA202_0<=UNDEF)||(LA202_0>=64 && LA202_0<=65)||(LA202_0>=68 && LA202_0<=80)||LA202_0==82||LA202_0==88||(LA202_0>=132 && LA202_0<=133)||(LA202_0>=135 && LA202_0<=152)||LA202_0==154||(LA202_0>=156 && LA202_0<=168)||LA202_0==170||(LA202_0>=177 && LA202_0<=178)||(LA202_0>=195 && LA202_0<=202)))
			{
				alt202=1;
			}
			} finally { DebugExitDecision(202); }
			switch (alt202)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:719:8: interface_member_declarations
				{
				DebugLocation(719, 8);
				PushFollow(Follow._interface_member_declarations_in_interface_body5567);
				interface_member_declarations704=interface_member_declarations();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_member_declarations704.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(202); }

			DebugLocation(719, 41);
			char_literal705=(IToken)Match(input,63,Follow._63_in_interface_body5572); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal705_tree = (object)adaptor.Create(char_literal705);
			adaptor.AddChild(root_0, char_literal705_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_body", 207);
			LeaveRule("interface_body", 207);
			Leave_interface_body();
			if (state.backtracking > 0) { Memoize(input, 207, interface_body_StartIndex); }
		}
		DebugLocation(719, 44);
		} finally { DebugExitRule(GrammarFileName, "interface_body"); }
		return retval;

	}
	// $ANTLR end "interface_body"

	public class interface_member_declarations_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_member_declarations();
	partial void Leave_interface_member_declarations();

	// $ANTLR start "interface_member_declarations"
	// cs.g:720:8: public interface_member_declarations : ( interface_member_declaration )+ ;
	[GrammarRule("interface_member_declarations")]
	public csParser.interface_member_declarations_return interface_member_declarations()
	{
		Enter_interface_member_declarations();
		EnterRule("interface_member_declarations", 208);
		TraceIn("interface_member_declarations", 208);
		csParser.interface_member_declarations_return retval = new csParser.interface_member_declarations_return();
		retval.Start = (IToken)input.LT(1);
		int interface_member_declarations_StartIndex = input.Index;
		object root_0 = null;

		csParser.interface_member_declaration_return interface_member_declaration706 = default(csParser.interface_member_declaration_return);


		try { DebugEnterRule(GrammarFileName, "interface_member_declarations");
		DebugLocation(720, 31);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 208)) { return retval; }
			// cs.g:720:37: ( ( interface_member_declaration )+ )
			DebugEnterAlt(1);
			// cs.g:721:2: ( interface_member_declaration )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(721, 2);
			// cs.g:721:2: ( interface_member_declaration )+
			int cnt203=0;
			try { DebugEnterSubRule(203);
			while (true)
			{
				int alt203=2;
				try { DebugEnterDecision(203, decisionCanBacktrack[203]);
				int LA203_0 = input.LA(1);

				if ((LA203_0==IDENTIFIER||(LA203_0>=ELIF && LA203_0<=UNDEF)||(LA203_0>=64 && LA203_0<=65)||(LA203_0>=68 && LA203_0<=80)||LA203_0==82||LA203_0==88||(LA203_0>=132 && LA203_0<=133)||(LA203_0>=135 && LA203_0<=152)||LA203_0==154||(LA203_0>=156 && LA203_0<=168)||LA203_0==170||(LA203_0>=177 && LA203_0<=178)||(LA203_0>=195 && LA203_0<=202)))
				{
					alt203=1;
				}


				} finally { DebugExitDecision(203); }
				switch (alt203)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:721:2: interface_member_declaration
					{
					DebugLocation(721, 2);
					PushFollow(Follow._interface_member_declaration_in_interface_member_declarations5582);
					interface_member_declaration706=interface_member_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_member_declaration706.Tree);

					}
					break;

				default:
					if (cnt203 >= 1)
						goto loop203;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee203 = new EarlyExitException( 203, input );
					DebugRecognitionException(eee203);
					throw eee203;
				}
				cnt203++;
			}
			loop203:
				;

			} finally { DebugExitSubRule(203); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_member_declarations", 208);
			LeaveRule("interface_member_declarations", 208);
			Leave_interface_member_declarations();
			if (state.backtracking > 0) { Memoize(input, 208, interface_member_declarations_StartIndex); }
		}
		DebugLocation(721, 31);
		} finally { DebugExitRule(GrammarFileName, "interface_member_declarations"); }
		return retval;

	}
	// $ANTLR end "interface_member_declarations"

	public class interface_member_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_member_declaration();
	partial void Leave_interface_member_declaration();

	// $ANTLR start "interface_member_declaration"
	// cs.g:722:8: public interface_member_declaration : ( attributes )? ( modifiers )? ( 'void' interface_method_declaration | interface_event_declaration | type ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration ) ) ;
	[GrammarRule("interface_member_declaration")]
	public csParser.interface_member_declaration_return interface_member_declaration()
	{
		Enter_interface_member_declaration();
		EnterRule("interface_member_declaration", 209);
		TraceIn("interface_member_declaration", 209);
		csParser.interface_member_declaration_return retval = new csParser.interface_member_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int interface_member_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal709=null;
		csParser.attributes_return attributes707 = default(csParser.attributes_return);
		csParser.modifiers_return modifiers708 = default(csParser.modifiers_return);
		csParser.interface_method_declaration_return interface_method_declaration710 = default(csParser.interface_method_declaration_return);
		csParser.interface_event_declaration_return interface_event_declaration711 = default(csParser.interface_event_declaration_return);
		csParser.type_return type712 = default(csParser.type_return);
		csParser.interface_method_declaration_return interface_method_declaration713 = default(csParser.interface_method_declaration_return);
		csParser.interface_property_declaration_return interface_property_declaration714 = default(csParser.interface_property_declaration_return);
		csParser.interface_indexer_declaration_return interface_indexer_declaration715 = default(csParser.interface_indexer_declaration_return);

		object string_literal709_tree=null;

		try { DebugEnterRule(GrammarFileName, "interface_member_declaration");
		DebugLocation(722, 2);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 209)) { return retval; }
			// cs.g:722:36: ( ( attributes )? ( modifiers )? ( 'void' interface_method_declaration | interface_event_declaration | type ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration ) ) )
			DebugEnterAlt(1);
			// cs.g:723:2: ( attributes )? ( modifiers )? ( 'void' interface_method_declaration | interface_event_declaration | type ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration ) )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(723, 2);
			// cs.g:723:2: ( attributes )?
			int alt204=2;
			try { DebugEnterSubRule(204);
			try { DebugEnterDecision(204, decisionCanBacktrack[204]);
			int LA204_0 = input.LA(1);

			if ((LA204_0==88))
			{
				alt204=1;
			}
			} finally { DebugExitDecision(204); }
			switch (alt204)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:723:2: attributes
				{
				DebugLocation(723, 2);
				PushFollow(Follow._attributes_in_interface_member_declaration5593);
				attributes707=attributes();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes707.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(204); }

			DebugLocation(723, 17);
			// cs.g:723:17: ( modifiers )?
			int alt205=2;
			try { DebugEnterSubRule(205);
			try { DebugEnterDecision(205, decisionCanBacktrack[205]);
			int LA205_0 = input.LA(1);

			if ((LA205_0==64||(LA205_0>=68 && LA205_0<=80)))
			{
				alt205=1;
			}
			} finally { DebugExitDecision(205); }
			switch (alt205)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:723:17: modifiers
				{
				DebugLocation(723, 17);
				PushFollow(Follow._modifiers_in_interface_member_declaration5599);
				modifiers708=modifiers();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers708.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(205); }

			DebugLocation(724, 3);
			// cs.g:724:3: ( 'void' interface_method_declaration | interface_event_declaration | type ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration ) )
			int alt207=3;
			try { DebugEnterSubRule(207);
			try { DebugEnterDecision(207, decisionCanBacktrack[207]);
			switch (input.LA(1))
			{
			case 82:
				{
				int LA207_1 = input.LA(2);

				if ((LA207_1==IDENTIFIER||(LA207_1>=ELIF && LA207_1<=UNDEF)||LA207_1==65||(LA207_1>=132 && LA207_1<=133)||(LA207_1>=135 && LA207_1<=148)||(LA207_1>=150 && LA207_1<=152)||LA207_1==154||(LA207_1>=156 && LA207_1<=159)||LA207_1==170||(LA207_1>=177 && LA207_1<=178)||LA207_1==195||LA207_1==202))
				{
					alt207=1;
				}
				else if ((LA207_1==102))
				{
					alt207=3;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 207, 1, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case 149:
				{
				alt207=2;
				}
				break;
			case IDENTIFIER:
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 132:
			case 133:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 170:
			case 177:
			case 178:
			case 195:
			case 196:
			case 197:
			case 198:
			case 199:
			case 200:
			case 201:
			case 202:
				{
				alt207=3;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 207, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(207); }
			switch (alt207)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:724:4: 'void' interface_method_declaration
				{
				DebugLocation(724, 4);
				string_literal709=(IToken)Match(input,82,Follow._82_in_interface_member_declaration5605); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal709_tree = (object)adaptor.Create(string_literal709);
				adaptor.AddChild(root_0, string_literal709_tree);
				}
				DebugLocation(724, 13);
				PushFollow(Follow._interface_method_declaration_in_interface_member_declaration5609);
				interface_method_declaration710=interface_method_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_method_declaration710.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:725:5: interface_event_declaration
				{
				DebugLocation(725, 5);
				PushFollow(Follow._interface_event_declaration_in_interface_member_declaration5615);
				interface_event_declaration711=interface_event_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_event_declaration711.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:726:5: type ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration )
				{
				DebugLocation(726, 5);
				PushFollow(Follow._type_in_interface_member_declaration5621);
				type712=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type712.Tree);
				DebugLocation(726, 12);
				// cs.g:726:12: ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration )
				int alt206=3;
				try { DebugEnterSubRule(206);
				try { DebugEnterDecision(206, decisionCanBacktrack[206]);
				switch (input.LA(1))
				{
				case IDENTIFIER:
					{
					int LA206_1 = input.LA(2);

					if ((LA206_1==101) && (EvaluatePredicate(synpred26_cs_fragment)))
					{
						alt206=1;
					}
					else if ((LA206_1==90) && (EvaluatePredicate(synpred26_cs_fragment)))
					{
						alt206=1;
					}
					else if ((LA206_1==62) && (EvaluatePredicate(synpred27_cs_fragment)))
					{
						alt206=2;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 206, 1, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
					}
					break;
				case ELIF:
				case ENDIF:
				case DEFINE:
				case UNDEF:
				case 65:
				case 132:
				case 133:
				case 135:
				case 136:
				case 137:
				case 138:
				case 139:
				case 140:
				case 141:
				case 142:
				case 143:
				case 144:
				case 145:
				case 146:
				case 147:
				case 148:
				case 150:
				case 151:
				case 152:
				case 154:
				case 156:
				case 157:
				case 158:
				case 159:
				case 170:
				case 177:
				case 178:
				case 195:
				case 202:
					{
					int LA206_2 = input.LA(2);

					if ((LA206_2==101) && (EvaluatePredicate(synpred26_cs_fragment)))
					{
						alt206=1;
					}
					else if ((LA206_2==90) && (EvaluatePredicate(synpred26_cs_fragment)))
					{
						alt206=1;
					}
					else if ((LA206_2==62) && (EvaluatePredicate(synpred27_cs_fragment)))
					{
						alt206=2;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 206, 2, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
					}
					break;
				case 83:
					{
					alt206=3;
					}
					break;
				default:
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 206, 0, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
				}

				} finally { DebugExitDecision(206); }
				switch (alt206)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:726:14: ( member_name '(' )=> interface_method_declaration
					{
					DebugLocation(726, 37);
					PushFollow(Follow._interface_method_declaration_in_interface_member_declaration5637);
					interface_method_declaration713=interface_method_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_method_declaration713.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:727:14: ( member_name '{' )=> interface_property_declaration
					{
					DebugLocation(727, 37);
					PushFollow(Follow._interface_property_declaration_in_interface_member_declaration5662);
					interface_property_declaration714=interface_property_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_property_declaration714.Tree);

					}
					break;
				case 3:
					DebugEnterAlt(3);
					// cs.g:728:8: interface_indexer_declaration
					{
					DebugLocation(728, 8);
					PushFollow(Follow._interface_indexer_declaration_in_interface_member_declaration5672);
					interface_indexer_declaration715=interface_indexer_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_indexer_declaration715.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(206); }


				}
				break;

			}
			} finally { DebugExitSubRule(207); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_member_declaration", 209);
			LeaveRule("interface_member_declaration", 209);
			Leave_interface_member_declaration();
			if (state.backtracking > 0) { Memoize(input, 209, interface_member_declaration_StartIndex); }
		}
		DebugLocation(730, 2);
		} finally { DebugExitRule(GrammarFileName, "interface_member_declaration"); }
		return retval;

	}
	// $ANTLR end "interface_member_declaration"

	public class interface_property_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_property_declaration();
	partial void Leave_interface_property_declaration();

	// $ANTLR start "interface_property_declaration"
	// cs.g:731:8: public interface_property_declaration : identifier '{' interface_accessor_declarations '}' ;
	[GrammarRule("interface_property_declaration")]
	public csParser.interface_property_declaration_return interface_property_declaration()
	{
		Enter_interface_property_declaration();
		EnterRule("interface_property_declaration", 210);
		TraceIn("interface_property_declaration", 210);
		csParser.interface_property_declaration_return retval = new csParser.interface_property_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int interface_property_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal717=null;
		IToken char_literal719=null;
		csParser.identifier_return identifier716 = default(csParser.identifier_return);
		csParser.interface_accessor_declarations_return interface_accessor_declarations718 = default(csParser.interface_accessor_declarations_return);

		object char_literal717_tree=null;
		object char_literal719_tree=null;

		try { DebugEnterRule(GrammarFileName, "interface_property_declaration");
		DebugLocation(731, 58);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 210)) { return retval; }
			// cs.g:731:38: ( identifier '{' interface_accessor_declarations '}' )
			DebugEnterAlt(1);
			// cs.g:732:2: identifier '{' interface_accessor_declarations '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(732, 2);
			PushFollow(Follow._identifier_in_interface_property_declaration5691);
			identifier716=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier716.Tree);
			DebugLocation(732, 15);
			char_literal717=(IToken)Match(input,62,Follow._62_in_interface_property_declaration5695); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal717_tree = (object)adaptor.Create(char_literal717);
			adaptor.AddChild(root_0, char_literal717_tree);
			}
			DebugLocation(732, 21);
			PushFollow(Follow._interface_accessor_declarations_in_interface_property_declaration5699);
			interface_accessor_declarations718=interface_accessor_declarations();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_accessor_declarations718.Tree);
			DebugLocation(732, 55);
			char_literal719=(IToken)Match(input,63,Follow._63_in_interface_property_declaration5703); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal719_tree = (object)adaptor.Create(char_literal719);
			adaptor.AddChild(root_0, char_literal719_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_property_declaration", 210);
			LeaveRule("interface_property_declaration", 210);
			Leave_interface_property_declaration();
			if (state.backtracking > 0) { Memoize(input, 210, interface_property_declaration_StartIndex); }
		}
		DebugLocation(732, 58);
		} finally { DebugExitRule(GrammarFileName, "interface_property_declaration"); }
		return retval;

	}
	// $ANTLR end "interface_property_declaration"

	public class interface_method_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_method_declaration();
	partial void Leave_interface_method_declaration();

	// $ANTLR start "interface_method_declaration"
	// cs.g:733:8: public interface_method_declaration : identifier ( generic_argument_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';' ;
	[GrammarRule("interface_method_declaration")]
	public csParser.interface_method_declaration_return interface_method_declaration()
	{
		Enter_interface_method_declaration();
		EnterRule("interface_method_declaration", 211);
		TraceIn("interface_method_declaration", 211);
		csParser.interface_method_declaration_return retval = new csParser.interface_method_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int interface_method_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal722=null;
		IToken char_literal724=null;
		IToken char_literal726=null;
		csParser.identifier_return identifier720 = default(csParser.identifier_return);
		csParser.generic_argument_list_return generic_argument_list721 = default(csParser.generic_argument_list_return);
		csParser.formal_parameter_list_return formal_parameter_list723 = default(csParser.formal_parameter_list_return);
		csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses725 = default(csParser.type_parameter_constraints_clauses_return);

		object char_literal722_tree=null;
		object char_literal724_tree=null;
		object char_literal726_tree=null;

		try { DebugEnterRule(GrammarFileName, "interface_method_declaration");
		DebugLocation(733, 84);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 211)) { return retval; }
			// cs.g:733:36: ( identifier ( generic_argument_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';' )
			DebugEnterAlt(1);
			// cs.g:734:2: identifier ( generic_argument_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(734, 2);
			PushFollow(Follow._identifier_in_interface_method_declaration5713);
			identifier720=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier720.Tree);
			DebugLocation(734, 15);
			// cs.g:734:15: ( generic_argument_list )?
			int alt208=2;
			try { DebugEnterSubRule(208);
			try { DebugEnterDecision(208, decisionCanBacktrack[208]);
			int LA208_0 = input.LA(1);

			if ((LA208_0==101))
			{
				alt208=1;
			}
			} finally { DebugExitDecision(208); }
			switch (alt208)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:734:15: generic_argument_list
				{
				DebugLocation(734, 15);
				PushFollow(Follow._generic_argument_list_in_interface_method_declaration5717);
				generic_argument_list721=generic_argument_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_argument_list721.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(208); }

			DebugLocation(735, 6);
			char_literal722=(IToken)Match(input,90,Follow._90_in_interface_method_declaration5725); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal722_tree = (object)adaptor.Create(char_literal722);
			adaptor.AddChild(root_0, char_literal722_tree);
			}
			DebugLocation(735, 12);
			// cs.g:735:12: ( formal_parameter_list )?
			int alt209=2;
			try { DebugEnterSubRule(209);
			try { DebugEnterDecision(209, decisionCanBacktrack[209]);
			int LA209_0 = input.LA(1);

			if ((LA209_0==IDENTIFIER||(LA209_0>=ELIF && LA209_0<=UNDEF)||LA209_0==65||(LA209_0>=82 && LA209_0<=83)||LA209_0==88||(LA209_0>=93 && LA209_0<=94)||(LA209_0>=132 && LA209_0<=133)||(LA209_0>=135 && LA209_0<=148)||(LA209_0>=150 && LA209_0<=152)||LA209_0==154||(LA209_0>=156 && LA209_0<=168)||(LA209_0>=170 && LA209_0<=171)||(LA209_0>=177 && LA209_0<=178)||(LA209_0>=195 && LA209_0<=202)))
			{
				alt209=1;
			}
			} finally { DebugExitDecision(209); }
			switch (alt209)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:735:12: formal_parameter_list
				{
				DebugLocation(735, 12);
				PushFollow(Follow._formal_parameter_list_in_interface_method_declaration5729);
				formal_parameter_list723=formal_parameter_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list723.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(209); }

			DebugLocation(735, 37);
			char_literal724=(IToken)Match(input,RPAREN,Follow._RPAREN_in_interface_method_declaration5734); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal724_tree = (object)adaptor.Create(char_literal724);
			adaptor.AddChild(root_0, char_literal724_tree);
			}
			DebugLocation(735, 43);
			// cs.g:735:43: ( type_parameter_constraints_clauses )?
			int alt210=2;
			try { DebugEnterSubRule(210);
			try { DebugEnterDecision(210, decisionCanBacktrack[210]);
			int LA210_0 = input.LA(1);

			if ((LA210_0==145))
			{
				alt210=1;
			}
			} finally { DebugExitDecision(210); }
			switch (alt210)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:735:43: type_parameter_constraints_clauses
				{
				DebugLocation(735, 43);
				PushFollow(Follow._type_parameter_constraints_clauses_in_interface_method_declaration5738);
				type_parameter_constraints_clauses725=type_parameter_constraints_clauses();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses725.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(210); }

			DebugLocation(735, 81);
			char_literal726=(IToken)Match(input,SEMI,Follow._SEMI_in_interface_method_declaration5743); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal726_tree = (object)adaptor.Create(char_literal726);
			adaptor.AddChild(root_0, char_literal726_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_method_declaration", 211);
			LeaveRule("interface_method_declaration", 211);
			Leave_interface_method_declaration();
			if (state.backtracking > 0) { Memoize(input, 211, interface_method_declaration_StartIndex); }
		}
		DebugLocation(735, 84);
		} finally { DebugExitRule(GrammarFileName, "interface_method_declaration"); }
		return retval;

	}
	// $ANTLR end "interface_method_declaration"

	public class interface_event_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_event_declaration();
	partial void Leave_interface_event_declaration();

	// $ANTLR start "interface_event_declaration"
	// cs.g:736:8: public interface_event_declaration : 'event' type identifier ';' ;
	[GrammarRule("interface_event_declaration")]
	public csParser.interface_event_declaration_return interface_event_declaration()
	{
		Enter_interface_event_declaration();
		EnterRule("interface_event_declaration", 212);
		TraceIn("interface_event_declaration", 212);
		csParser.interface_event_declaration_return retval = new csParser.interface_event_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int interface_event_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal727=null;
		IToken char_literal730=null;
		csParser.type_return type728 = default(csParser.type_return);
		csParser.identifier_return identifier729 = default(csParser.identifier_return);

		object string_literal727_tree=null;
		object char_literal730_tree=null;

		try { DebugEnterRule(GrammarFileName, "interface_event_declaration");
		DebugLocation(736, 35);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 212)) { return retval; }
			// cs.g:736:35: ( 'event' type identifier ';' )
			DebugEnterAlt(1);
			// cs.g:738:2: 'event' type identifier ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(738, 2);
			string_literal727=(IToken)Match(input,149,Follow._149_in_interface_event_declaration5756); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal727_tree = (object)adaptor.Create(string_literal727);
			adaptor.AddChild(root_0, string_literal727_tree);
			}
			DebugLocation(738, 12);
			PushFollow(Follow._type_in_interface_event_declaration5760);
			type728=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type728.Tree);
			DebugLocation(738, 19);
			PushFollow(Follow._identifier_in_interface_event_declaration5764);
			identifier729=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier729.Tree);
			DebugLocation(738, 32);
			char_literal730=(IToken)Match(input,SEMI,Follow._SEMI_in_interface_event_declaration5768); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal730_tree = (object)adaptor.Create(char_literal730);
			adaptor.AddChild(root_0, char_literal730_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_event_declaration", 212);
			LeaveRule("interface_event_declaration", 212);
			Leave_interface_event_declaration();
			if (state.backtracking > 0) { Memoize(input, 212, interface_event_declaration_StartIndex); }
		}
		DebugLocation(738, 35);
		} finally { DebugExitRule(GrammarFileName, "interface_event_declaration"); }
		return retval;

	}
	// $ANTLR end "interface_event_declaration"

	public class interface_indexer_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_indexer_declaration();
	partial void Leave_interface_indexer_declaration();

	// $ANTLR start "interface_indexer_declaration"
	// cs.g:739:8: public interface_indexer_declaration : 'this' '[' formal_parameter_list ']' '{' interface_accessor_declarations '}' ;
	[GrammarRule("interface_indexer_declaration")]
	public csParser.interface_indexer_declaration_return interface_indexer_declaration()
	{
		Enter_interface_indexer_declaration();
		EnterRule("interface_indexer_declaration", 213);
		TraceIn("interface_indexer_declaration", 213);
		csParser.interface_indexer_declaration_return retval = new csParser.interface_indexer_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int interface_indexer_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal731=null;
		IToken char_literal732=null;
		IToken char_literal734=null;
		IToken char_literal735=null;
		IToken char_literal737=null;
		csParser.formal_parameter_list_return formal_parameter_list733 = default(csParser.formal_parameter_list_return);
		csParser.interface_accessor_declarations_return interface_accessor_declarations736 = default(csParser.interface_accessor_declarations_return);

		object string_literal731_tree=null;
		object char_literal732_tree=null;
		object char_literal734_tree=null;
		object char_literal735_tree=null;
		object char_literal737_tree=null;

		try { DebugEnterRule(GrammarFileName, "interface_indexer_declaration");
		DebugLocation(739, 90);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 213)) { return retval; }
			// cs.g:739:37: ( 'this' '[' formal_parameter_list ']' '{' interface_accessor_declarations '}' )
			DebugEnterAlt(1);
			// cs.g:741:2: 'this' '[' formal_parameter_list ']' '{' interface_accessor_declarations '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(741, 2);
			string_literal731=(IToken)Match(input,83,Follow._83_in_interface_indexer_declaration5782); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal731_tree = (object)adaptor.Create(string_literal731);
			adaptor.AddChild(root_0, string_literal731_tree);
			}
			DebugLocation(741, 11);
			char_literal732=(IToken)Match(input,88,Follow._88_in_interface_indexer_declaration5786); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal732_tree = (object)adaptor.Create(char_literal732);
			adaptor.AddChild(root_0, char_literal732_tree);
			}
			DebugLocation(741, 17);
			PushFollow(Follow._formal_parameter_list_in_interface_indexer_declaration5790);
			formal_parameter_list733=formal_parameter_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list733.Tree);
			DebugLocation(741, 41);
			char_literal734=(IToken)Match(input,89,Follow._89_in_interface_indexer_declaration5794); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal734_tree = (object)adaptor.Create(char_literal734);
			adaptor.AddChild(root_0, char_literal734_tree);
			}
			DebugLocation(741, 47);
			char_literal735=(IToken)Match(input,62,Follow._62_in_interface_indexer_declaration5798); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal735_tree = (object)adaptor.Create(char_literal735);
			adaptor.AddChild(root_0, char_literal735_tree);
			}
			DebugLocation(741, 53);
			PushFollow(Follow._interface_accessor_declarations_in_interface_indexer_declaration5802);
			interface_accessor_declarations736=interface_accessor_declarations();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_accessor_declarations736.Tree);
			DebugLocation(741, 87);
			char_literal737=(IToken)Match(input,63,Follow._63_in_interface_indexer_declaration5806); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal737_tree = (object)adaptor.Create(char_literal737);
			adaptor.AddChild(root_0, char_literal737_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_indexer_declaration", 213);
			LeaveRule("interface_indexer_declaration", 213);
			Leave_interface_indexer_declaration();
			if (state.backtracking > 0) { Memoize(input, 213, interface_indexer_declaration_StartIndex); }
		}
		DebugLocation(741, 90);
		} finally { DebugExitRule(GrammarFileName, "interface_indexer_declaration"); }
		return retval;

	}
	// $ANTLR end "interface_indexer_declaration"

	public class interface_accessor_declarations_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_accessor_declarations();
	partial void Leave_interface_accessor_declarations();

	// $ANTLR start "interface_accessor_declarations"
	// cs.g:742:8: public interface_accessor_declarations : ( attributes )? ( interface_get_accessor_declaration ( attributes )? ( interface_set_accessor_declaration )? | interface_set_accessor_declaration ( attributes )? ( interface_get_accessor_declaration )? ) ;
	[GrammarRule("interface_accessor_declarations")]
	public csParser.interface_accessor_declarations_return interface_accessor_declarations()
	{
		Enter_interface_accessor_declarations();
		EnterRule("interface_accessor_declarations", 214);
		TraceIn("interface_accessor_declarations", 214);
		csParser.interface_accessor_declarations_return retval = new csParser.interface_accessor_declarations_return();
		retval.Start = (IToken)input.LT(1);
		int interface_accessor_declarations_StartIndex = input.Index;
		object root_0 = null;

		csParser.attributes_return attributes738 = default(csParser.attributes_return);
		csParser.interface_get_accessor_declaration_return interface_get_accessor_declaration739 = default(csParser.interface_get_accessor_declaration_return);
		csParser.attributes_return attributes740 = default(csParser.attributes_return);
		csParser.interface_set_accessor_declaration_return interface_set_accessor_declaration741 = default(csParser.interface_set_accessor_declaration_return);
		csParser.interface_set_accessor_declaration_return interface_set_accessor_declaration742 = default(csParser.interface_set_accessor_declaration_return);
		csParser.attributes_return attributes743 = default(csParser.attributes_return);
		csParser.interface_get_accessor_declaration_return interface_get_accessor_declaration744 = default(csParser.interface_get_accessor_declaration_return);


		try { DebugEnterRule(GrammarFileName, "interface_accessor_declarations");
		DebugLocation(742, 92);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 214)) { return retval; }
			// cs.g:742:39: ( ( attributes )? ( interface_get_accessor_declaration ( attributes )? ( interface_set_accessor_declaration )? | interface_set_accessor_declaration ( attributes )? ( interface_get_accessor_declaration )? ) )
			DebugEnterAlt(1);
			// cs.g:743:2: ( attributes )? ( interface_get_accessor_declaration ( attributes )? ( interface_set_accessor_declaration )? | interface_set_accessor_declaration ( attributes )? ( interface_get_accessor_declaration )? )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(743, 2);
			// cs.g:743:2: ( attributes )?
			int alt211=2;
			try { DebugEnterSubRule(211);
			try { DebugEnterDecision(211, decisionCanBacktrack[211]);
			int LA211_0 = input.LA(1);

			if ((LA211_0==88))
			{
				alt211=1;
			}
			} finally { DebugExitDecision(211); }
			switch (alt211)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:743:2: attributes
				{
				DebugLocation(743, 2);
				PushFollow(Follow._attributes_in_interface_accessor_declarations5816);
				attributes738=attributes();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes738.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(211); }

			DebugLocation(744, 3);
			// cs.g:744:3: ( interface_get_accessor_declaration ( attributes )? ( interface_set_accessor_declaration )? | interface_set_accessor_declaration ( attributes )? ( interface_get_accessor_declaration )? )
			int alt216=2;
			try { DebugEnterSubRule(216);
			try { DebugEnterDecision(216, decisionCanBacktrack[216]);
			int LA216_0 = input.LA(1);

			if ((LA216_0==156))
			{
				alt216=1;
			}
			else if ((LA216_0==157))
			{
				alt216=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 216, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(216); }
			switch (alt216)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:744:4: interface_get_accessor_declaration ( attributes )? ( interface_set_accessor_declaration )?
				{
				DebugLocation(744, 4);
				PushFollow(Follow._interface_get_accessor_declaration_in_interface_accessor_declarations5825);
				interface_get_accessor_declaration739=interface_get_accessor_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_get_accessor_declaration739.Tree);
				DebugLocation(744, 41);
				// cs.g:744:41: ( attributes )?
				int alt212=2;
				try { DebugEnterSubRule(212);
				try { DebugEnterDecision(212, decisionCanBacktrack[212]);
				int LA212_0 = input.LA(1);

				if ((LA212_0==88))
				{
					alt212=1;
				}
				} finally { DebugExitDecision(212); }
				switch (alt212)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:744:41: attributes
					{
					DebugLocation(744, 41);
					PushFollow(Follow._attributes_in_interface_accessor_declarations5829);
					attributes740=attributes();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes740.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(212); }

				DebugLocation(744, 55);
				// cs.g:744:55: ( interface_set_accessor_declaration )?
				int alt213=2;
				try { DebugEnterSubRule(213);
				try { DebugEnterDecision(213, decisionCanBacktrack[213]);
				int LA213_0 = input.LA(1);

				if ((LA213_0==157))
				{
					alt213=1;
				}
				} finally { DebugExitDecision(213); }
				switch (alt213)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:744:55: interface_set_accessor_declaration
					{
					DebugLocation(744, 55);
					PushFollow(Follow._interface_set_accessor_declaration_in_interface_accessor_declarations5834);
					interface_set_accessor_declaration741=interface_set_accessor_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_set_accessor_declaration741.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(213); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:745:5: interface_set_accessor_declaration ( attributes )? ( interface_get_accessor_declaration )?
				{
				DebugLocation(745, 5);
				PushFollow(Follow._interface_set_accessor_declaration_in_interface_accessor_declarations5841);
				interface_set_accessor_declaration742=interface_set_accessor_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_set_accessor_declaration742.Tree);
				DebugLocation(745, 42);
				// cs.g:745:42: ( attributes )?
				int alt214=2;
				try { DebugEnterSubRule(214);
				try { DebugEnterDecision(214, decisionCanBacktrack[214]);
				int LA214_0 = input.LA(1);

				if ((LA214_0==88))
				{
					alt214=1;
				}
				} finally { DebugExitDecision(214); }
				switch (alt214)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:745:42: attributes
					{
					DebugLocation(745, 42);
					PushFollow(Follow._attributes_in_interface_accessor_declarations5845);
					attributes743=attributes();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes743.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(214); }

				DebugLocation(745, 56);
				// cs.g:745:56: ( interface_get_accessor_declaration )?
				int alt215=2;
				try { DebugEnterSubRule(215);
				try { DebugEnterDecision(215, decisionCanBacktrack[215]);
				int LA215_0 = input.LA(1);

				if ((LA215_0==156))
				{
					alt215=1;
				}
				} finally { DebugExitDecision(215); }
				switch (alt215)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:745:56: interface_get_accessor_declaration
					{
					DebugLocation(745, 56);
					PushFollow(Follow._interface_get_accessor_declaration_in_interface_accessor_declarations5850);
					interface_get_accessor_declaration744=interface_get_accessor_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_get_accessor_declaration744.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(215); }


				}
				break;

			}
			} finally { DebugExitSubRule(216); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_accessor_declarations", 214);
			LeaveRule("interface_accessor_declarations", 214);
			Leave_interface_accessor_declarations();
			if (state.backtracking > 0) { Memoize(input, 214, interface_accessor_declarations_StartIndex); }
		}
		DebugLocation(745, 92);
		} finally { DebugExitRule(GrammarFileName, "interface_accessor_declarations"); }
		return retval;

	}
	// $ANTLR end "interface_accessor_declarations"

	public class interface_get_accessor_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_get_accessor_declaration();
	partial void Leave_interface_get_accessor_declaration();

	// $ANTLR start "interface_get_accessor_declaration"
	// cs.g:746:8: public interface_get_accessor_declaration : 'get' ';' ;
	[GrammarRule("interface_get_accessor_declaration")]
	public csParser.interface_get_accessor_declaration_return interface_get_accessor_declaration()
	{
		Enter_interface_get_accessor_declaration();
		EnterRule("interface_get_accessor_declaration", 215);
		TraceIn("interface_get_accessor_declaration", 215);
		csParser.interface_get_accessor_declaration_return retval = new csParser.interface_get_accessor_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int interface_get_accessor_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal745=null;
		IToken char_literal746=null;

		object string_literal745_tree=null;
		object char_literal746_tree=null;

		try { DebugEnterRule(GrammarFileName, "interface_get_accessor_declaration");
		DebugLocation(746, 13);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 215)) { return retval; }
			// cs.g:746:42: ( 'get' ';' )
			DebugEnterAlt(1);
			// cs.g:747:2: 'get' ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(747, 2);
			string_literal745=(IToken)Match(input,156,Follow._156_in_interface_get_accessor_declaration5862); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal745_tree = (object)adaptor.Create(string_literal745);
			adaptor.AddChild(root_0, string_literal745_tree);
			}
			DebugLocation(747, 10);
			char_literal746=(IToken)Match(input,SEMI,Follow._SEMI_in_interface_get_accessor_declaration5866); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal746_tree = (object)adaptor.Create(char_literal746);
			adaptor.AddChild(root_0, char_literal746_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_get_accessor_declaration", 215);
			LeaveRule("interface_get_accessor_declaration", 215);
			Leave_interface_get_accessor_declaration();
			if (state.backtracking > 0) { Memoize(input, 215, interface_get_accessor_declaration_StartIndex); }
		}
		DebugLocation(747, 13);
		} finally { DebugExitRule(GrammarFileName, "interface_get_accessor_declaration"); }
		return retval;

	}
	// $ANTLR end "interface_get_accessor_declaration"

	public class interface_set_accessor_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_interface_set_accessor_declaration();
	partial void Leave_interface_set_accessor_declaration();

	// $ANTLR start "interface_set_accessor_declaration"
	// cs.g:748:8: public interface_set_accessor_declaration : 'set' ';' ;
	[GrammarRule("interface_set_accessor_declaration")]
	public csParser.interface_set_accessor_declaration_return interface_set_accessor_declaration()
	{
		Enter_interface_set_accessor_declaration();
		EnterRule("interface_set_accessor_declaration", 216);
		TraceIn("interface_set_accessor_declaration", 216);
		csParser.interface_set_accessor_declaration_return retval = new csParser.interface_set_accessor_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int interface_set_accessor_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal747=null;
		IToken char_literal748=null;

		object string_literal747_tree=null;
		object char_literal748_tree=null;

		try { DebugEnterRule(GrammarFileName, "interface_set_accessor_declaration");
		DebugLocation(748, 13);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 216)) { return retval; }
			// cs.g:748:42: ( 'set' ';' )
			DebugEnterAlt(1);
			// cs.g:749:2: 'set' ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(749, 2);
			string_literal747=(IToken)Match(input,157,Follow._157_in_interface_set_accessor_declaration5878); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal747_tree = (object)adaptor.Create(string_literal747);
			adaptor.AddChild(root_0, string_literal747_tree);
			}
			DebugLocation(749, 10);
			char_literal748=(IToken)Match(input,SEMI,Follow._SEMI_in_interface_set_accessor_declaration5882); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal748_tree = (object)adaptor.Create(char_literal748);
			adaptor.AddChild(root_0, char_literal748_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("interface_set_accessor_declaration", 216);
			LeaveRule("interface_set_accessor_declaration", 216);
			Leave_interface_set_accessor_declaration();
			if (state.backtracking > 0) { Memoize(input, 216, interface_set_accessor_declaration_StartIndex); }
		}
		DebugLocation(749, 13);
		} finally { DebugExitRule(GrammarFileName, "interface_set_accessor_declaration"); }
		return retval;

	}
	// $ANTLR end "interface_set_accessor_declaration"

	public class method_modifiers_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_method_modifiers();
	partial void Leave_method_modifiers();

	// $ANTLR start "method_modifiers"
	// cs.g:750:8: public method_modifiers : ( modifier )+ ;
	[GrammarRule("method_modifiers")]
	public csParser.method_modifiers_return method_modifiers()
	{
		Enter_method_modifiers();
		EnterRule("method_modifiers", 217);
		TraceIn("method_modifiers", 217);
		csParser.method_modifiers_return retval = new csParser.method_modifiers_return();
		retval.Start = (IToken)input.LT(1);
		int method_modifiers_StartIndex = input.Index;
		object root_0 = null;

		csParser.modifier_return modifier749 = default(csParser.modifier_return);


		try { DebugEnterRule(GrammarFileName, "method_modifiers");
		DebugLocation(750, 11);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 217)) { return retval; }
			// cs.g:750:24: ( ( modifier )+ )
			DebugEnterAlt(1);
			// cs.g:751:2: ( modifier )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(751, 2);
			// cs.g:751:2: ( modifier )+
			int cnt217=0;
			try { DebugEnterSubRule(217);
			while (true)
			{
				int alt217=2;
				try { DebugEnterDecision(217, decisionCanBacktrack[217]);
				int LA217_0 = input.LA(1);

				if ((LA217_0==64||(LA217_0>=68 && LA217_0<=80)))
				{
					alt217=1;
				}


				} finally { DebugExitDecision(217); }
				switch (alt217)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:751:2: modifier
					{
					DebugLocation(751, 2);
					PushFollow(Follow._modifier_in_method_modifiers5894);
					modifier749=modifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifier749.Tree);

					}
					break;

				default:
					if (cnt217 >= 1)
						goto loop217;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee217 = new EarlyExitException( 217, input );
					DebugRecognitionException(eee217);
					throw eee217;
				}
				cnt217++;
			}
			loop217:
				;

			} finally { DebugExitSubRule(217); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("method_modifiers", 217);
			LeaveRule("method_modifiers", 217);
			Leave_method_modifiers();
			if (state.backtracking > 0) { Memoize(input, 217, method_modifiers_StartIndex); }
		}
		DebugLocation(751, 11);
		} finally { DebugExitRule(GrammarFileName, "method_modifiers"); }
		return retval;

	}
	// $ANTLR end "method_modifiers"

	public class struct_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_struct_declaration();
	partial void Leave_struct_declaration();

	// $ANTLR start "struct_declaration"
	// cs.g:754:8: public struct_declaration : 'struct' type_or_generic ( struct_interfaces )? ( type_parameter_constraints_clauses )? struct_body ( ';' )? ;
	[GrammarRule("struct_declaration")]
	public csParser.struct_declaration_return struct_declaration()
	{
		Enter_struct_declaration();
		EnterRule("struct_declaration", 218);
		TraceIn("struct_declaration", 218);
		csParser.struct_declaration_return retval = new csParser.struct_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int struct_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal750=null;
		IToken char_literal755=null;
		csParser.type_or_generic_return type_or_generic751 = default(csParser.type_or_generic_return);
		csParser.struct_interfaces_return struct_interfaces752 = default(csParser.struct_interfaces_return);
		csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses753 = default(csParser.type_parameter_constraints_clauses_return);
		csParser.struct_body_return struct_body754 = default(csParser.struct_body_return);

		object string_literal750_tree=null;
		object char_literal755_tree=null;

		try { DebugEnterRule(GrammarFileName, "struct_declaration");
		DebugLocation(754, 108);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 218)) { return retval; }
			// cs.g:754:26: ( 'struct' type_or_generic ( struct_interfaces )? ( type_parameter_constraints_clauses )? struct_body ( ';' )? )
			DebugEnterAlt(1);
			// cs.g:755:2: 'struct' type_or_generic ( struct_interfaces )? ( type_parameter_constraints_clauses )? struct_body ( ';' )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(755, 2);
			string_literal750=(IToken)Match(input,169,Follow._169_in_struct_declaration5908); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal750_tree = (object)adaptor.Create(string_literal750);
			adaptor.AddChild(root_0, string_literal750_tree);
			}
			DebugLocation(755, 13);
			PushFollow(Follow._type_or_generic_in_struct_declaration5912);
			type_or_generic751=type_or_generic();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic751.Tree);
			DebugLocation(755, 31);
			// cs.g:755:31: ( struct_interfaces )?
			int alt218=2;
			try { DebugEnterSubRule(218);
			try { DebugEnterDecision(218, decisionCanBacktrack[218]);
			int LA218_0 = input.LA(1);

			if ((LA218_0==92))
			{
				alt218=1;
			}
			} finally { DebugExitDecision(218); }
			switch (alt218)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:755:31: struct_interfaces
				{
				DebugLocation(755, 31);
				PushFollow(Follow._struct_interfaces_in_struct_declaration5916);
				struct_interfaces752=struct_interfaces();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_interfaces752.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(218); }

			DebugLocation(755, 52);
			// cs.g:755:52: ( type_parameter_constraints_clauses )?
			int alt219=2;
			try { DebugEnterSubRule(219);
			try { DebugEnterDecision(219, decisionCanBacktrack[219]);
			int LA219_0 = input.LA(1);

			if ((LA219_0==145))
			{
				alt219=1;
			}
			} finally { DebugExitDecision(219); }
			switch (alt219)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:755:52: type_parameter_constraints_clauses
				{
				DebugLocation(755, 52);
				PushFollow(Follow._type_parameter_constraints_clauses_in_struct_declaration5921);
				type_parameter_constraints_clauses753=type_parameter_constraints_clauses();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses753.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(219); }

			DebugLocation(755, 90);
			PushFollow(Follow._struct_body_in_struct_declaration5926);
			struct_body754=struct_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_body754.Tree);
			DebugLocation(755, 104);
			// cs.g:755:104: ( ';' )?
			int alt220=2;
			try { DebugEnterSubRule(220);
			try { DebugEnterDecision(220, decisionCanBacktrack[220]);
			int LA220_0 = input.LA(1);

			if ((LA220_0==SEMI))
			{
				alt220=1;
			}
			} finally { DebugExitDecision(220); }
			switch (alt220)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:755:104: ';'
				{
				DebugLocation(755, 104);
				char_literal755=(IToken)Match(input,SEMI,Follow._SEMI_in_struct_declaration5930); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal755_tree = (object)adaptor.Create(char_literal755);
				adaptor.AddChild(root_0, char_literal755_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(220); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("struct_declaration", 218);
			LeaveRule("struct_declaration", 218);
			Leave_struct_declaration();
			if (state.backtracking > 0) { Memoize(input, 218, struct_declaration_StartIndex); }
		}
		DebugLocation(755, 108);
		} finally { DebugExitRule(GrammarFileName, "struct_declaration"); }
		return retval;

	}
	// $ANTLR end "struct_declaration"

	public class struct_modifiers_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_struct_modifiers();
	partial void Leave_struct_modifiers();

	// $ANTLR start "struct_modifiers"
	// cs.g:756:8: public struct_modifiers : ( struct_modifier )+ ;
	[GrammarRule("struct_modifiers")]
	public csParser.struct_modifiers_return struct_modifiers()
	{
		Enter_struct_modifiers();
		EnterRule("struct_modifiers", 219);
		TraceIn("struct_modifiers", 219);
		csParser.struct_modifiers_return retval = new csParser.struct_modifiers_return();
		retval.Start = (IToken)input.LT(1);
		int struct_modifiers_StartIndex = input.Index;
		object root_0 = null;

		csParser.struct_modifier_return struct_modifier756 = default(csParser.struct_modifier_return);


		try { DebugEnterRule(GrammarFileName, "struct_modifiers");
		DebugLocation(756, 18);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 219)) { return retval; }
			// cs.g:756:24: ( ( struct_modifier )+ )
			DebugEnterAlt(1);
			// cs.g:757:2: ( struct_modifier )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(757, 2);
			// cs.g:757:2: ( struct_modifier )+
			int cnt221=0;
			try { DebugEnterSubRule(221);
			while (true)
			{
				int alt221=2;
				try { DebugEnterDecision(221, decisionCanBacktrack[221]);
				int LA221_0 = input.LA(1);

				if (((LA221_0>=68 && LA221_0<=73)))
				{
					alt221=1;
				}


				} finally { DebugExitDecision(221); }
				switch (alt221)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:757:2: struct_modifier
					{
					DebugLocation(757, 2);
					PushFollow(Follow._struct_modifier_in_struct_modifiers5941);
					struct_modifier756=struct_modifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_modifier756.Tree);

					}
					break;

				default:
					if (cnt221 >= 1)
						goto loop221;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee221 = new EarlyExitException( 221, input );
					DebugRecognitionException(eee221);
					throw eee221;
				}
				cnt221++;
			}
			loop221:
				;

			} finally { DebugExitSubRule(221); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("struct_modifiers", 219);
			LeaveRule("struct_modifiers", 219);
			Leave_struct_modifiers();
			if (state.backtracking > 0) { Memoize(input, 219, struct_modifiers_StartIndex); }
		}
		DebugLocation(757, 18);
		} finally { DebugExitRule(GrammarFileName, "struct_modifiers"); }
		return retval;

	}
	// $ANTLR end "struct_modifiers"

	public class struct_modifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_struct_modifier();
	partial void Leave_struct_modifier();

	// $ANTLR start "struct_modifier"
	// cs.g:758:8: public struct_modifier : ( 'new' | 'public' | 'protected' | 'internal' | 'private' | 'unsafe' );
	[GrammarRule("struct_modifier")]
	public csParser.struct_modifier_return struct_modifier()
	{
		Enter_struct_modifier();
		EnterRule("struct_modifier", 220);
		TraceIn("struct_modifier", 220);
		csParser.struct_modifier_return retval = new csParser.struct_modifier_return();
		retval.Start = (IToken)input.LT(1);
		int struct_modifier_StartIndex = input.Index;
		object root_0 = null;

		IToken set757=null;

		object set757_tree=null;

		try { DebugEnterRule(GrammarFileName, "struct_modifier");
		DebugLocation(758, 68);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 220)) { return retval; }
			// cs.g:758:23: ( 'new' | 'public' | 'protected' | 'internal' | 'private' | 'unsafe' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(758, 23);
			set757=(IToken)input.LT(1);
			if ((input.LA(1)>=68 && input.LA(1)<=73))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set757));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("struct_modifier", 220);
			LeaveRule("struct_modifier", 220);
			Leave_struct_modifier();
			if (state.backtracking > 0) { Memoize(input, 220, struct_modifier_StartIndex); }
		}
		DebugLocation(759, 68);
		} finally { DebugExitRule(GrammarFileName, "struct_modifier"); }
		return retval;

	}
	// $ANTLR end "struct_modifier"

	public class struct_interfaces_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_struct_interfaces();
	partial void Leave_struct_interfaces();

	// $ANTLR start "struct_interfaces"
	// cs.g:760:8: public struct_interfaces : ':' interface_type_list ;
	[GrammarRule("struct_interfaces")]
	public csParser.struct_interfaces_return struct_interfaces()
	{
		Enter_struct_interfaces();
		EnterRule("struct_interfaces", 221);
		TraceIn("struct_interfaces", 221);
		csParser.struct_interfaces_return retval = new csParser.struct_interfaces_return();
		retval.Start = (IToken)input.LT(1);
		int struct_interfaces_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal758=null;
		csParser.interface_type_list_return interface_type_list759 = default(csParser.interface_type_list_return);

		object char_literal758_tree=null;

		try { DebugEnterRule(GrammarFileName, "struct_interfaces");
		DebugLocation(760, 26);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 221)) { return retval; }
			// cs.g:760:25: ( ':' interface_type_list )
			DebugEnterAlt(1);
			// cs.g:761:2: ':' interface_type_list
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(761, 2);
			char_literal758=(IToken)Match(input,92,Follow._92_in_struct_interfaces5982); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal758_tree = (object)adaptor.Create(char_literal758);
			adaptor.AddChild(root_0, char_literal758_tree);
			}
			DebugLocation(761, 8);
			PushFollow(Follow._interface_type_list_in_struct_interfaces5986);
			interface_type_list759=interface_type_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_type_list759.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("struct_interfaces", 221);
			LeaveRule("struct_interfaces", 221);
			Leave_struct_interfaces();
			if (state.backtracking > 0) { Memoize(input, 221, struct_interfaces_StartIndex); }
		}
		DebugLocation(761, 26);
		} finally { DebugExitRule(GrammarFileName, "struct_interfaces"); }
		return retval;

	}
	// $ANTLR end "struct_interfaces"

	public class struct_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_struct_body();
	partial void Leave_struct_body();

	// $ANTLR start "struct_body"
	// cs.g:762:8: public struct_body : '{' ( struct_member_declarations )? '}' ;
	[GrammarRule("struct_body")]
	public csParser.struct_body_return struct_body()
	{
		Enter_struct_body();
		EnterRule("struct_body", 222);
		TraceIn("struct_body", 222);
		csParser.struct_body_return retval = new csParser.struct_body_return();
		retval.Start = (IToken)input.LT(1);
		int struct_body_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal760=null;
		IToken char_literal762=null;
		csParser.struct_member_declarations_return struct_member_declarations761 = default(csParser.struct_member_declarations_return);

		object char_literal760_tree=null;
		object char_literal762_tree=null;

		try { DebugEnterRule(GrammarFileName, "struct_body");
		DebugLocation(762, 40);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 222)) { return retval; }
			// cs.g:762:19: ( '{' ( struct_member_declarations )? '}' )
			DebugEnterAlt(1);
			// cs.g:763:2: '{' ( struct_member_declarations )? '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(763, 2);
			char_literal760=(IToken)Match(input,62,Follow._62_in_struct_body5995); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal760_tree = (object)adaptor.Create(char_literal760);
			adaptor.AddChild(root_0, char_literal760_tree);
			}
			DebugLocation(763, 8);
			// cs.g:763:8: ( struct_member_declarations )?
			int alt222=2;
			try { DebugEnterSubRule(222);
			try { DebugEnterDecision(222, decisionCanBacktrack[222]);
			int LA222_0 = input.LA(1);

			if ((LA222_0==IDENTIFIER||LA222_0==ENUM||(LA222_0>=ELIF && LA222_0<=UNDEF)||(LA222_0>=64 && LA222_0<=65)||(LA222_0>=67 && LA222_0<=82)||LA222_0==88||LA222_0==99||(LA222_0>=132 && LA222_0<=133)||(LA222_0>=135 && LA222_0<=152)||(LA222_0>=154 && LA222_0<=170)||LA222_0==172||(LA222_0>=174 && LA222_0<=175)||(LA222_0>=177 && LA222_0<=178)||(LA222_0>=195 && LA222_0<=202)))
			{
				alt222=1;
			}
			} finally { DebugExitDecision(222); }
			switch (alt222)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:763:8: struct_member_declarations
				{
				DebugLocation(763, 8);
				PushFollow(Follow._struct_member_declarations_in_struct_body5999);
				struct_member_declarations761=struct_member_declarations();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_member_declarations761.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(222); }

			DebugLocation(763, 38);
			char_literal762=(IToken)Match(input,63,Follow._63_in_struct_body6004); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal762_tree = (object)adaptor.Create(char_literal762);
			adaptor.AddChild(root_0, char_literal762_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("struct_body", 222);
			LeaveRule("struct_body", 222);
			Leave_struct_body();
			if (state.backtracking > 0) { Memoize(input, 222, struct_body_StartIndex); }
		}
		DebugLocation(763, 40);
		} finally { DebugExitRule(GrammarFileName, "struct_body"); }
		return retval;

	}
	// $ANTLR end "struct_body"

	public class struct_member_declarations_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_struct_member_declarations();
	partial void Leave_struct_member_declarations();

	// $ANTLR start "struct_member_declarations"
	// cs.g:764:8: public struct_member_declarations : ( struct_member_declaration )+ ;
	[GrammarRule("struct_member_declarations")]
	public csParser.struct_member_declarations_return struct_member_declarations()
	{
		Enter_struct_member_declarations();
		EnterRule("struct_member_declarations", 223);
		TraceIn("struct_member_declarations", 223);
		csParser.struct_member_declarations_return retval = new csParser.struct_member_declarations_return();
		retval.Start = (IToken)input.LT(1);
		int struct_member_declarations_StartIndex = input.Index;
		object root_0 = null;

		csParser.struct_member_declaration_return struct_member_declaration763 = default(csParser.struct_member_declaration_return);


		try { DebugEnterRule(GrammarFileName, "struct_member_declarations");
		DebugLocation(764, 28);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 223)) { return retval; }
			// cs.g:764:34: ( ( struct_member_declaration )+ )
			DebugEnterAlt(1);
			// cs.g:765:2: ( struct_member_declaration )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(765, 2);
			// cs.g:765:2: ( struct_member_declaration )+
			int cnt223=0;
			try { DebugEnterSubRule(223);
			while (true)
			{
				int alt223=2;
				try { DebugEnterDecision(223, decisionCanBacktrack[223]);
				int LA223_0 = input.LA(1);

				if ((LA223_0==IDENTIFIER||LA223_0==ENUM||(LA223_0>=ELIF && LA223_0<=UNDEF)||(LA223_0>=64 && LA223_0<=65)||(LA223_0>=67 && LA223_0<=82)||LA223_0==88||LA223_0==99||(LA223_0>=132 && LA223_0<=133)||(LA223_0>=135 && LA223_0<=152)||(LA223_0>=154 && LA223_0<=170)||LA223_0==172||(LA223_0>=174 && LA223_0<=175)||(LA223_0>=177 && LA223_0<=178)||(LA223_0>=195 && LA223_0<=202)))
				{
					alt223=1;
				}


				} finally { DebugExitDecision(223); }
				switch (alt223)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:765:2: struct_member_declaration
					{
					DebugLocation(765, 2);
					PushFollow(Follow._struct_member_declaration_in_struct_member_declarations6013);
					struct_member_declaration763=struct_member_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_member_declaration763.Tree);

					}
					break;

				default:
					if (cnt223 >= 1)
						goto loop223;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee223 = new EarlyExitException( 223, input );
					DebugRecognitionException(eee223);
					throw eee223;
				}
				cnt223++;
			}
			loop223:
				;

			} finally { DebugExitSubRule(223); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("struct_member_declarations", 223);
			LeaveRule("struct_member_declarations", 223);
			Leave_struct_member_declarations();
			if (state.backtracking > 0) { Memoize(input, 223, struct_member_declarations_StartIndex); }
		}
		DebugLocation(765, 28);
		} finally { DebugExitRule(GrammarFileName, "struct_member_declarations"); }
		return retval;

	}
	// $ANTLR end "struct_member_declarations"

	public class struct_member_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_struct_member_declaration();
	partial void Leave_struct_member_declaration();

	// $ANTLR start "struct_member_declaration"
	// cs.g:766:8: public struct_member_declaration : ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | class_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration ) ;
	[GrammarRule("struct_member_declaration")]
	public csParser.struct_member_declaration_return struct_member_declaration()
	{
		Enter_struct_member_declaration();
		EnterRule("struct_member_declaration", 224);
		TraceIn("struct_member_declaration", 224);
		csParser.struct_member_declaration_return retval = new csParser.struct_member_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int struct_member_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal765=null;
		IToken char_literal768=null;
		IToken string_literal770=null;
		IToken string_literal777=null;
		IToken char_literal783=null;
		csParser.modifiers_return m = default(csParser.modifiers_return);
		csParser.attributes_return attributes764 = default(csParser.attributes_return);
		csParser.type_return type766 = default(csParser.type_return);
		csParser.constant_declarators_return constant_declarators767 = default(csParser.constant_declarators_return);
		csParser.event_declaration_return event_declaration769 = default(csParser.event_declaration_return);
		csParser.method_declaration_return method_declaration771 = default(csParser.method_declaration_return);
		csParser.interface_declaration_return interface_declaration772 = default(csParser.interface_declaration_return);
		csParser.class_declaration_return class_declaration773 = default(csParser.class_declaration_return);
		csParser.struct_declaration_return struct_declaration774 = default(csParser.struct_declaration_return);
		csParser.interface_declaration_return interface_declaration775 = default(csParser.interface_declaration_return);
		csParser.class_declaration_return class_declaration776 = default(csParser.class_declaration_return);
		csParser.method_declaration_return method_declaration778 = default(csParser.method_declaration_return);
		csParser.type_return type779 = default(csParser.type_return);
		csParser.method_declaration_return method_declaration780 = default(csParser.method_declaration_return);
		csParser.property_declaration_return property_declaration781 = default(csParser.property_declaration_return);
		csParser.type_name_return type_name782 = default(csParser.type_name_return);
		csParser.indexer_declaration_return indexer_declaration784 = default(csParser.indexer_declaration_return);
		csParser.indexer_declaration_return indexer_declaration785 = default(csParser.indexer_declaration_return);
		csParser.field_declaration_return field_declaration786 = default(csParser.field_declaration_return);
		csParser.operator_declaration_return operator_declaration787 = default(csParser.operator_declaration_return);
		csParser.struct_declaration_return struct_declaration788 = default(csParser.struct_declaration_return);
		csParser.enum_declaration_return enum_declaration789 = default(csParser.enum_declaration_return);
		csParser.delegate_declaration_return delegate_declaration790 = default(csParser.delegate_declaration_return);
		csParser.conversion_operator_declaration_return conversion_operator_declaration791 = default(csParser.conversion_operator_declaration_return);
		csParser.constructor_declaration_return constructor_declaration792 = default(csParser.constructor_declaration_return);

		object string_literal765_tree=null;
		object char_literal768_tree=null;
		object string_literal770_tree=null;
		object string_literal777_tree=null;
		object char_literal783_tree=null;

		try { DebugEnterRule(GrammarFileName, "struct_member_declaration");
		DebugLocation(766, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 224)) { return retval; }
			// cs.g:766:33: ( ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | class_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration ) )
			DebugEnterAlt(1);
			// cs.g:767:2: ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | class_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(767, 2);
			// cs.g:767:2: ( attributes )?
			int alt224=2;
			try { DebugEnterSubRule(224);
			try { DebugEnterDecision(224, decisionCanBacktrack[224]);
			int LA224_0 = input.LA(1);

			if ((LA224_0==88))
			{
				alt224=1;
			}
			} finally { DebugExitDecision(224); }
			switch (alt224)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:767:2: attributes
				{
				DebugLocation(767, 2);
				PushFollow(Follow._attributes_in_struct_member_declaration6024);
				attributes764=attributes();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes764.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(224); }

			DebugLocation(767, 17);
			// cs.g:767:17: (m= modifiers )?
			int alt225=2;
			try { DebugEnterSubRule(225);
			try { DebugEnterDecision(225, decisionCanBacktrack[225]);
			int LA225_0 = input.LA(1);

			if ((LA225_0==64||(LA225_0>=68 && LA225_0<=80)))
			{
				alt225=1;
			}
			} finally { DebugExitDecision(225); }
			switch (alt225)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:767:17: m= modifiers
				{
				DebugLocation(767, 17);
				PushFollow(Follow._modifiers_in_struct_member_declaration6031);
				m=modifiers();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, m.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(225); }

			DebugLocation(768, 2);
			// cs.g:768:2: ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | class_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration )
			int alt228=12;
			try { DebugEnterSubRule(228);
			try { DebugEnterDecision(228, decisionCanBacktrack[228]);
			try
			{
				alt228 = dfa228.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(228); }
			switch (alt228)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:768:4: 'const' type constant_declarators ';'
				{
				DebugLocation(768, 4);
				string_literal765=(IToken)Match(input,81,Follow._81_in_struct_member_declaration6037); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal765_tree = (object)adaptor.Create(string_literal765);
				adaptor.AddChild(root_0, string_literal765_tree);
				}
				DebugLocation(768, 14);
				PushFollow(Follow._type_in_struct_member_declaration6041);
				type766=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type766.Tree);
				DebugLocation(768, 21);
				PushFollow(Follow._constant_declarators_in_struct_member_declaration6045);
				constant_declarators767=constant_declarators();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarators767.Tree);
				DebugLocation(768, 44);
				char_literal768=(IToken)Match(input,SEMI,Follow._SEMI_in_struct_member_declaration6049); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal768_tree = (object)adaptor.Create(char_literal768);
				adaptor.AddChild(root_0, char_literal768_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:769:4: event_declaration
				{
				DebugLocation(769, 4);
				PushFollow(Follow._event_declaration_in_struct_member_declaration6054);
				event_declaration769=event_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, event_declaration769.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:770:4: 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration )
				{
				DebugLocation(770, 4);
				string_literal770=(IToken)Match(input,67,Follow._67_in_struct_member_declaration6061); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal770_tree = (object)adaptor.Create(string_literal770);
				adaptor.AddChild(root_0, string_literal770_tree);
				}
				DebugLocation(770, 14);
				// cs.g:770:14: ( method_declaration | interface_declaration | class_declaration | struct_declaration )
				int alt226=4;
				try { DebugEnterSubRule(226);
				try { DebugEnterDecision(226, decisionCanBacktrack[226]);
				switch (input.LA(1))
				{
				case IDENTIFIER:
				case Real_literal:
				case NUMBER:
				case Hex_number:
				case Character_literal:
				case STRINGLITERAL:
				case Verbatim_string_literal:
				case TRUE:
				case FALSE:
				case NULL:
				case ELIF:
				case ENDIF:
				case DEFINE:
				case UNDEF:
				case 65:
				case 132:
				case 133:
				case 135:
				case 136:
				case 137:
				case 138:
				case 139:
				case 140:
				case 141:
				case 142:
				case 143:
				case 144:
				case 145:
				case 146:
				case 147:
				case 148:
				case 150:
				case 151:
				case 152:
				case 154:
				case 156:
				case 157:
				case 158:
				case 159:
				case 160:
				case 161:
				case 162:
				case 163:
				case 164:
				case 165:
				case 166:
				case 167:
				case 168:
				case 170:
				case 177:
				case 178:
				case 195:
				case 196:
				case 197:
				case 198:
				case 199:
				case 200:
				case 201:
				case 202:
					{
					alt226=1;
					}
					break;
				case 172:
					{
					alt226=2;
					}
					break;
				case 155:
					{
					alt226=3;
					}
					break;
				case 169:
					{
					alt226=4;
					}
					break;
				default:
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 226, 0, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
				}

				} finally { DebugExitDecision(226); }
				switch (alt226)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:770:15: method_declaration
					{
					DebugLocation(770, 15);
					PushFollow(Follow._method_declaration_in_struct_member_declaration6064);
					method_declaration771=method_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration771.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:771:9: interface_declaration
					{
					DebugLocation(771, 9);
					PushFollow(Follow._interface_declaration_in_struct_member_declaration6075);
					interface_declaration772=interface_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration772.Tree);

					}
					break;
				case 3:
					DebugEnterAlt(3);
					// cs.g:772:9: class_declaration
					{
					DebugLocation(772, 9);
					PushFollow(Follow._class_declaration_in_struct_member_declaration6086);
					class_declaration773=class_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration773.Tree);

					}
					break;
				case 4:
					DebugEnterAlt(4);
					// cs.g:773:9: struct_declaration
					{
					DebugLocation(773, 9);
					PushFollow(Follow._struct_declaration_in_struct_member_declaration6097);
					struct_declaration774=struct_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration774.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(226); }


				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:775:4: interface_declaration
				{
				DebugLocation(775, 4);
				PushFollow(Follow._interface_declaration_in_struct_member_declaration6104);
				interface_declaration775=interface_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration775.Tree);

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:776:4: class_declaration
				{
				DebugLocation(776, 4);
				PushFollow(Follow._class_declaration_in_struct_member_declaration6110);
				class_declaration776=class_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration776.Tree);

				}
				break;
			case 6:
				DebugEnterAlt(6);
				// cs.g:777:4: 'void' method_declaration
				{
				DebugLocation(777, 4);
				string_literal777=(IToken)Match(input,82,Follow._82_in_struct_member_declaration6117); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal777_tree = (object)adaptor.Create(string_literal777);
				adaptor.AddChild(root_0, string_literal777_tree);
				}
				DebugLocation(777, 13);
				PushFollow(Follow._method_declaration_in_struct_member_declaration6121);
				method_declaration778=method_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration778.Tree);

				}
				break;
			case 7:
				DebugEnterAlt(7);
				// cs.g:778:4: type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )
				{
				DebugLocation(778, 4);
				PushFollow(Follow._type_in_struct_member_declaration6126);
				type779=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type779.Tree);
				DebugLocation(778, 9);
				// cs.g:778:9: ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )
				int alt227=6;
				try { DebugEnterSubRule(227);
				try { DebugEnterDecision(227, decisionCanBacktrack[227]);
				try
				{
					alt227 = dfa227.Predict(input);
				}
				catch (NoViableAltException nvae)
				{
					DebugRecognitionException(nvae);
					throw;
				}
				} finally { DebugExitDecision(227); }
				switch (alt227)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:778:11: ( member_name '(' )=> method_declaration
					{
					DebugLocation(778, 34);
					PushFollow(Follow._method_declaration_in_struct_member_declaration6140);
					method_declaration780=method_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration780.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:779:8: ( member_name '{' )=> property_declaration
					{
					DebugLocation(779, 31);
					PushFollow(Follow._property_declaration_in_struct_member_declaration6159);
					property_declaration781=property_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, property_declaration781.Tree);

					}
					break;
				case 3:
					DebugEnterAlt(3);
					// cs.g:780:8: ( member_name '.' 'this' )=> type_name '.' indexer_declaration
					{
					DebugLocation(780, 40);
					PushFollow(Follow._type_name_in_struct_member_declaration6182);
					type_name782=type_name();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name782.Tree);
					DebugLocation(780, 50);
					char_literal783=(IToken)Match(input,DOT,Follow._DOT_in_struct_member_declaration6184); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal783_tree = (object)adaptor.Create(char_literal783);
					adaptor.AddChild(root_0, char_literal783_tree);
					}
					DebugLocation(780, 54);
					PushFollow(Follow._indexer_declaration_in_struct_member_declaration6186);
					indexer_declaration784=indexer_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, indexer_declaration784.Tree);

					}
					break;
				case 4:
					DebugEnterAlt(4);
					// cs.g:781:8: indexer_declaration
					{
					DebugLocation(781, 8);
					PushFollow(Follow._indexer_declaration_in_struct_member_declaration6195);
					indexer_declaration785=indexer_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, indexer_declaration785.Tree);

					}
					break;
				case 5:
					DebugEnterAlt(5);
					// cs.g:782:11: field_declaration
					{
					DebugLocation(782, 11);
					PushFollow(Follow._field_declaration_in_struct_member_declaration6208);
					field_declaration786=field_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, field_declaration786.Tree);

					}
					break;
				case 6:
					DebugEnterAlt(6);
					// cs.g:783:11: operator_declaration
					{
					DebugLocation(783, 11);
					PushFollow(Follow._operator_declaration_in_struct_member_declaration6226);
					operator_declaration787=operator_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, operator_declaration787.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(227); }


				}
				break;
			case 8:
				DebugEnterAlt(8);
				// cs.g:787:4: struct_declaration
				{
				DebugLocation(787, 4);
				PushFollow(Follow._struct_declaration_in_struct_member_declaration6244);
				struct_declaration788=struct_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration788.Tree);

				}
				break;
			case 9:
				DebugEnterAlt(9);
				// cs.g:788:4: enum_declaration
				{
				DebugLocation(788, 4);
				PushFollow(Follow._enum_declaration_in_struct_member_declaration6250);
				enum_declaration789=enum_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_declaration789.Tree);

				}
				break;
			case 10:
				DebugEnterAlt(10);
				// cs.g:789:4: delegate_declaration
				{
				DebugLocation(789, 4);
				PushFollow(Follow._delegate_declaration_in_struct_member_declaration6257);
				delegate_declaration790=delegate_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, delegate_declaration790.Tree);

				}
				break;
			case 11:
				DebugEnterAlt(11);
				// cs.g:790:4: conversion_operator_declaration
				{
				DebugLocation(790, 4);
				PushFollow(Follow._conversion_operator_declaration_in_struct_member_declaration6263);
				conversion_operator_declaration791=conversion_operator_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conversion_operator_declaration791.Tree);

				}
				break;
			case 12:
				DebugEnterAlt(12);
				// cs.g:791:4: constructor_declaration
				{
				DebugLocation(791, 4);
				PushFollow(Follow._constructor_declaration_in_struct_member_declaration6268);
				constructor_declaration792=constructor_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_declaration792.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(228); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("struct_member_declaration", 224);
			LeaveRule("struct_member_declaration", 224);
			Leave_struct_member_declaration();
			if (state.backtracking > 0) { Memoize(input, 224, struct_member_declaration_StartIndex); }
		}
		DebugLocation(793, 1);
		} finally { DebugExitRule(GrammarFileName, "struct_member_declaration"); }
		return retval;

	}
	// $ANTLR end "struct_member_declaration"

	public class indexer_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_indexer_declaration();
	partial void Leave_indexer_declaration();

	// $ANTLR start "indexer_declaration"
	// cs.g:797:8: public indexer_declaration : indexer_declarator '{' accessor_declarations '}' ;
	[GrammarRule("indexer_declaration")]
	public csParser.indexer_declaration_return indexer_declaration()
	{
		Enter_indexer_declaration();
		EnterRule("indexer_declaration", 225);
		TraceIn("indexer_declaration", 225);
		csParser.indexer_declaration_return retval = new csParser.indexer_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int indexer_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal794=null;
		IToken char_literal796=null;
		csParser.indexer_declarator_return indexer_declarator793 = default(csParser.indexer_declarator_return);
		csParser.accessor_declarations_return accessor_declarations795 = default(csParser.accessor_declarations_return);

		object char_literal794_tree=null;
		object char_literal796_tree=null;

		try { DebugEnterRule(GrammarFileName, "indexer_declaration");
		DebugLocation(797, 56);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 225)) { return retval; }
			// cs.g:797:27: ( indexer_declarator '{' accessor_declarations '}' )
			DebugEnterAlt(1);
			// cs.g:798:2: indexer_declarator '{' accessor_declarations '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(798, 2);
			PushFollow(Follow._indexer_declarator_in_indexer_declaration6287);
			indexer_declarator793=indexer_declarator();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, indexer_declarator793.Tree);
			DebugLocation(798, 23);
			char_literal794=(IToken)Match(input,62,Follow._62_in_indexer_declaration6291); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal794_tree = (object)adaptor.Create(char_literal794);
			adaptor.AddChild(root_0, char_literal794_tree);
			}
			DebugLocation(798, 29);
			PushFollow(Follow._accessor_declarations_in_indexer_declaration6295);
			accessor_declarations795=accessor_declarations();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_declarations795.Tree);
			DebugLocation(798, 53);
			char_literal796=(IToken)Match(input,63,Follow._63_in_indexer_declaration6299); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal796_tree = (object)adaptor.Create(char_literal796);
			adaptor.AddChild(root_0, char_literal796_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("indexer_declaration", 225);
			LeaveRule("indexer_declaration", 225);
			Leave_indexer_declaration();
			if (state.backtracking > 0) { Memoize(input, 225, indexer_declaration_StartIndex); }
		}
		DebugLocation(798, 56);
		} finally { DebugExitRule(GrammarFileName, "indexer_declaration"); }
		return retval;

	}
	// $ANTLR end "indexer_declaration"

	public class indexer_declarator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_indexer_declarator();
	partial void Leave_indexer_declarator();

	// $ANTLR start "indexer_declarator"
	// cs.g:799:8: public indexer_declarator : 'this' '[' formal_parameter_list ']' ;
	[GrammarRule("indexer_declarator")]
	public csParser.indexer_declarator_return indexer_declarator()
	{
		Enter_indexer_declarator();
		EnterRule("indexer_declarator", 226);
		TraceIn("indexer_declarator", 226);
		csParser.indexer_declarator_return retval = new csParser.indexer_declarator_return();
		retval.Start = (IToken)input.LT(1);
		int indexer_declarator_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal797=null;
		IToken char_literal798=null;
		IToken char_literal800=null;
		csParser.formal_parameter_list_return formal_parameter_list799 = default(csParser.formal_parameter_list_return);

		object string_literal797_tree=null;
		object char_literal798_tree=null;
		object char_literal800_tree=null;

		try { DebugEnterRule(GrammarFileName, "indexer_declarator");
		DebugLocation(799, 44);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 226)) { return retval; }
			// cs.g:799:26: ( 'this' '[' formal_parameter_list ']' )
			DebugEnterAlt(1);
			// cs.g:801:2: 'this' '[' formal_parameter_list ']'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(801, 2);
			string_literal797=(IToken)Match(input,83,Follow._83_in_indexer_declarator6311); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal797_tree = (object)adaptor.Create(string_literal797);
			adaptor.AddChild(root_0, string_literal797_tree);
			}
			DebugLocation(801, 11);
			char_literal798=(IToken)Match(input,88,Follow._88_in_indexer_declarator6315); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal798_tree = (object)adaptor.Create(char_literal798);
			adaptor.AddChild(root_0, char_literal798_tree);
			}
			DebugLocation(801, 17);
			PushFollow(Follow._formal_parameter_list_in_indexer_declarator6319);
			formal_parameter_list799=formal_parameter_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list799.Tree);
			DebugLocation(801, 41);
			char_literal800=(IToken)Match(input,89,Follow._89_in_indexer_declarator6323); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal800_tree = (object)adaptor.Create(char_literal800);
			adaptor.AddChild(root_0, char_literal800_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("indexer_declarator", 226);
			LeaveRule("indexer_declarator", 226);
			Leave_indexer_declarator();
			if (state.backtracking > 0) { Memoize(input, 226, indexer_declarator_StartIndex); }
		}
		DebugLocation(801, 44);
		} finally { DebugExitRule(GrammarFileName, "indexer_declarator"); }
		return retval;

	}
	// $ANTLR end "indexer_declarator"

	public class operator_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_operator_declaration();
	partial void Leave_operator_declaration();

	// $ANTLR start "operator_declaration"
	// cs.g:804:8: public operator_declaration : operator_declarator operator_body ;
	[GrammarRule("operator_declaration")]
	public csParser.operator_declaration_return operator_declaration()
	{
		Enter_operator_declaration();
		EnterRule("operator_declaration", 227);
		TraceIn("operator_declaration", 227);
		csParser.operator_declaration_return retval = new csParser.operator_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int operator_declaration_StartIndex = input.Index;
		object root_0 = null;

		csParser.operator_declarator_return operator_declarator801 = default(csParser.operator_declarator_return);
		csParser.operator_body_return operator_body802 = default(csParser.operator_body_return);


		try { DebugEnterRule(GrammarFileName, "operator_declaration");
		DebugLocation(804, 37);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 227)) { return retval; }
			// cs.g:804:28: ( operator_declarator operator_body )
			DebugEnterAlt(1);
			// cs.g:805:2: operator_declarator operator_body
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(805, 2);
			PushFollow(Follow._operator_declarator_in_operator_declaration6336);
			operator_declarator801=operator_declarator();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, operator_declarator801.Tree);
			DebugLocation(805, 24);
			PushFollow(Follow._operator_body_in_operator_declaration6340);
			operator_body802=operator_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, operator_body802.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("operator_declaration", 227);
			LeaveRule("operator_declaration", 227);
			Leave_operator_declaration();
			if (state.backtracking > 0) { Memoize(input, 227, operator_declaration_StartIndex); }
		}
		DebugLocation(805, 37);
		} finally { DebugExitRule(GrammarFileName, "operator_declaration"); }
		return retval;

	}
	// $ANTLR end "operator_declaration"

	public class operator_declarator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_operator_declarator();
	partial void Leave_operator_declarator();

	// $ANTLR start "operator_declarator"
	// cs.g:806:8: public operator_declarator : 'operator' ( ( '+' | '-' ) '(' type identifier ( binary_operator_declarator | unary_operator_declarator ) | overloadable_unary_operator '(' type identifier unary_operator_declarator | overloadable_binary_operator '(' type identifier binary_operator_declarator ) ;
	[GrammarRule("operator_declarator")]
	public csParser.operator_declarator_return operator_declarator()
	{
		Enter_operator_declarator();
		EnterRule("operator_declarator", 228);
		TraceIn("operator_declarator", 228);
		csParser.operator_declarator_return retval = new csParser.operator_declarator_return();
		retval.Start = (IToken)input.LT(1);
		int operator_declarator_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal803=null;
		IToken set804=null;
		IToken char_literal805=null;
		IToken char_literal811=null;
		IToken char_literal816=null;
		csParser.type_return type806 = default(csParser.type_return);
		csParser.identifier_return identifier807 = default(csParser.identifier_return);
		csParser.binary_operator_declarator_return binary_operator_declarator808 = default(csParser.binary_operator_declarator_return);
		csParser.unary_operator_declarator_return unary_operator_declarator809 = default(csParser.unary_operator_declarator_return);
		csParser.overloadable_unary_operator_return overloadable_unary_operator810 = default(csParser.overloadable_unary_operator_return);
		csParser.type_return type812 = default(csParser.type_return);
		csParser.identifier_return identifier813 = default(csParser.identifier_return);
		csParser.unary_operator_declarator_return unary_operator_declarator814 = default(csParser.unary_operator_declarator_return);
		csParser.overloadable_binary_operator_return overloadable_binary_operator815 = default(csParser.overloadable_binary_operator_return);
		csParser.type_return type817 = default(csParser.type_return);
		csParser.identifier_return identifier818 = default(csParser.identifier_return);
		csParser.binary_operator_declarator_return binary_operator_declarator819 = default(csParser.binary_operator_declarator_return);

		object string_literal803_tree=null;
		object set804_tree=null;
		object char_literal805_tree=null;
		object char_literal811_tree=null;
		object char_literal816_tree=null;

		try { DebugEnterRule(GrammarFileName, "operator_declarator");
		DebugLocation(806, 87);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 228)) { return retval; }
			// cs.g:806:27: ( 'operator' ( ( '+' | '-' ) '(' type identifier ( binary_operator_declarator | unary_operator_declarator ) | overloadable_unary_operator '(' type identifier unary_operator_declarator | overloadable_binary_operator '(' type identifier binary_operator_declarator ) )
			DebugEnterAlt(1);
			// cs.g:807:2: 'operator' ( ( '+' | '-' ) '(' type identifier ( binary_operator_declarator | unary_operator_declarator ) | overloadable_unary_operator '(' type identifier unary_operator_declarator | overloadable_binary_operator '(' type identifier binary_operator_declarator )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(807, 2);
			string_literal803=(IToken)Match(input,173,Follow._173_in_operator_declarator6350); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal803_tree = (object)adaptor.Create(string_literal803);
			adaptor.AddChild(root_0, string_literal803_tree);
			}
			DebugLocation(808, 2);
			// cs.g:808:2: ( ( '+' | '-' ) '(' type identifier ( binary_operator_declarator | unary_operator_declarator ) | overloadable_unary_operator '(' type identifier unary_operator_declarator | overloadable_binary_operator '(' type identifier binary_operator_declarator )
			int alt230=3;
			try { DebugEnterSubRule(230);
			try { DebugEnterDecision(230, decisionCanBacktrack[230]);
			switch (input.LA(1))
			{
			case MINUS:
			case 104:
				{
				alt230=1;
				}
				break;
			case TRUE:
			case FALSE:
			case 86:
			case 87:
			case 105:
			case 106:
				{
				alt230=2;
				}
				break;
			case GT:
			case 101:
			case 102:
			case 116:
			case 117:
			case 118:
			case 119:
			case 120:
			case 121:
			case 124:
			case 125:
			case 126:
			case 127:
				{
				alt230=3;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 230, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(230); }
			switch (alt230)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:808:3: ( '+' | '-' ) '(' type identifier ( binary_operator_declarator | unary_operator_declarator )
				{
				DebugLocation(808, 3);
				set804=(IToken)input.LT(1);
				if (input.LA(1)==MINUS||input.LA(1)==104)
				{
					input.Consume();
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set804));
					state.errorRecovery=false;state.failed=false;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					MismatchedSetException mse = new MismatchedSetException(null,input);
					DebugRecognitionException(mse);
					throw mse;
				}

				DebugLocation(808, 17);
				char_literal805=(IToken)Match(input,90,Follow._90_in_operator_declarator6365); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal805_tree = (object)adaptor.Create(char_literal805);
				adaptor.AddChild(root_0, char_literal805_tree);
				}
				DebugLocation(808, 23);
				PushFollow(Follow._type_in_operator_declarator6369);
				type806=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type806.Tree);
				DebugLocation(808, 30);
				PushFollow(Follow._identifier_in_operator_declarator6373);
				identifier807=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier807.Tree);
				DebugLocation(808, 43);
				// cs.g:808:43: ( binary_operator_declarator | unary_operator_declarator )
				int alt229=2;
				try { DebugEnterSubRule(229);
				try { DebugEnterDecision(229, decisionCanBacktrack[229]);
				int LA229_0 = input.LA(1);

				if ((LA229_0==91))
				{
					alt229=1;
				}
				else if ((LA229_0==RPAREN))
				{
					alt229=2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 229, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				} finally { DebugExitDecision(229); }
				switch (alt229)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:808:44: binary_operator_declarator
					{
					DebugLocation(808, 44);
					PushFollow(Follow._binary_operator_declarator_in_operator_declarator6378);
					binary_operator_declarator808=binary_operator_declarator();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, binary_operator_declarator808.Tree);

					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:808:73: unary_operator_declarator
					{
					DebugLocation(808, 73);
					PushFollow(Follow._unary_operator_declarator_in_operator_declarator6382);
					unary_operator_declarator809=unary_operator_declarator();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_operator_declarator809.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(229); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:809:5: overloadable_unary_operator '(' type identifier unary_operator_declarator
				{
				DebugLocation(809, 5);
				PushFollow(Follow._overloadable_unary_operator_in_operator_declarator6389);
				overloadable_unary_operator810=overloadable_unary_operator();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, overloadable_unary_operator810.Tree);
				DebugLocation(809, 35);
				char_literal811=(IToken)Match(input,90,Follow._90_in_operator_declarator6393); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal811_tree = (object)adaptor.Create(char_literal811);
				adaptor.AddChild(root_0, char_literal811_tree);
				}
				DebugLocation(809, 41);
				PushFollow(Follow._type_in_operator_declarator6397);
				type812=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type812.Tree);
				DebugLocation(809, 46);
				PushFollow(Follow._identifier_in_operator_declarator6399);
				identifier813=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier813.Tree);
				DebugLocation(809, 59);
				PushFollow(Follow._unary_operator_declarator_in_operator_declarator6403);
				unary_operator_declarator814=unary_operator_declarator();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_operator_declarator814.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:810:5: overloadable_binary_operator '(' type identifier binary_operator_declarator
				{
				DebugLocation(810, 5);
				PushFollow(Follow._overloadable_binary_operator_in_operator_declarator6409);
				overloadable_binary_operator815=overloadable_binary_operator();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, overloadable_binary_operator815.Tree);
				DebugLocation(810, 36);
				char_literal816=(IToken)Match(input,90,Follow._90_in_operator_declarator6413); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal816_tree = (object)adaptor.Create(char_literal816);
				adaptor.AddChild(root_0, char_literal816_tree);
				}
				DebugLocation(810, 42);
				PushFollow(Follow._type_in_operator_declarator6417);
				type817=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type817.Tree);
				DebugLocation(810, 47);
				PushFollow(Follow._identifier_in_operator_declarator6419);
				identifier818=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier818.Tree);
				DebugLocation(810, 60);
				PushFollow(Follow._binary_operator_declarator_in_operator_declarator6423);
				binary_operator_declarator819=binary_operator_declarator();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, binary_operator_declarator819.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(230); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("operator_declarator", 228);
			LeaveRule("operator_declarator", 228);
			Leave_operator_declarator();
			if (state.backtracking > 0) { Memoize(input, 228, operator_declarator_StartIndex); }
		}
		DebugLocation(810, 87);
		} finally { DebugExitRule(GrammarFileName, "operator_declarator"); }
		return retval;

	}
	// $ANTLR end "operator_declarator"

	public class unary_operator_declarator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_unary_operator_declarator();
	partial void Leave_unary_operator_declarator();

	// $ANTLR start "unary_operator_declarator"
	// cs.g:811:8: public unary_operator_declarator : ')' ;
	[GrammarRule("unary_operator_declarator")]
	public csParser.unary_operator_declarator_return unary_operator_declarator()
	{
		Enter_unary_operator_declarator();
		EnterRule("unary_operator_declarator", 229);
		TraceIn("unary_operator_declarator", 229);
		csParser.unary_operator_declarator_return retval = new csParser.unary_operator_declarator_return();
		retval.Start = (IToken)input.LT(1);
		int unary_operator_declarator_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal820=null;

		object char_literal820_tree=null;

		try { DebugEnterRule(GrammarFileName, "unary_operator_declarator");
		DebugLocation(811, 8);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 229)) { return retval; }
			// cs.g:811:33: ( ')' )
			DebugEnterAlt(1);
			// cs.g:812:5: ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(812, 5);
			char_literal820=(IToken)Match(input,RPAREN,Follow._RPAREN_in_unary_operator_declarator6437); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal820_tree = (object)adaptor.Create(char_literal820);
			adaptor.AddChild(root_0, char_literal820_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("unary_operator_declarator", 229);
			LeaveRule("unary_operator_declarator", 229);
			Leave_unary_operator_declarator();
			if (state.backtracking > 0) { Memoize(input, 229, unary_operator_declarator_StartIndex); }
		}
		DebugLocation(812, 8);
		} finally { DebugExitRule(GrammarFileName, "unary_operator_declarator"); }
		return retval;

	}
	// $ANTLR end "unary_operator_declarator"

	public class overloadable_unary_operator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_overloadable_unary_operator();
	partial void Leave_overloadable_unary_operator();

	// $ANTLR start "overloadable_unary_operator"
	// cs.g:813:8: public overloadable_unary_operator : ( '!' | '~' | '++' | '--' | 'true' | 'false' );
	[GrammarRule("overloadable_unary_operator")]
	public csParser.overloadable_unary_operator_return overloadable_unary_operator()
	{
		Enter_overloadable_unary_operator();
		EnterRule("overloadable_unary_operator", 230);
		TraceIn("overloadable_unary_operator", 230);
		csParser.overloadable_unary_operator_return retval = new csParser.overloadable_unary_operator_return();
		retval.Start = (IToken)input.LT(1);
		int overloadable_unary_operator_StartIndex = input.Index;
		object root_0 = null;

		IToken set821=null;

		object set821_tree=null;

		try { DebugEnterRule(GrammarFileName, "overloadable_unary_operator");
		DebugLocation(813, 67);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 230)) { return retval; }
			// cs.g:813:35: ( '!' | '~' | '++' | '--' | 'true' | 'false' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(813, 35);
			set821=(IToken)input.LT(1);
			if ((input.LA(1)>=TRUE && input.LA(1)<=FALSE)||(input.LA(1)>=86 && input.LA(1)<=87)||(input.LA(1)>=105 && input.LA(1)<=106))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set821));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("overloadable_unary_operator", 230);
			LeaveRule("overloadable_unary_operator", 230);
			Leave_overloadable_unary_operator();
			if (state.backtracking > 0) { Memoize(input, 230, overloadable_unary_operator_StartIndex); }
		}
		DebugLocation(814, 67);
		} finally { DebugExitRule(GrammarFileName, "overloadable_unary_operator"); }
		return retval;

	}
	// $ANTLR end "overloadable_unary_operator"

	public class binary_operator_declarator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_binary_operator_declarator();
	partial void Leave_binary_operator_declarator();

	// $ANTLR start "binary_operator_declarator"
	// cs.g:815:8: public binary_operator_declarator : ',' type identifier ')' ;
	[GrammarRule("binary_operator_declarator")]
	public csParser.binary_operator_declarator_return binary_operator_declarator()
	{
		Enter_binary_operator_declarator();
		EnterRule("binary_operator_declarator", 231);
		TraceIn("binary_operator_declarator", 231);
		csParser.binary_operator_declarator_return retval = new csParser.binary_operator_declarator_return();
		retval.Start = (IToken)input.LT(1);
		int binary_operator_declarator_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal822=null;
		IToken char_literal825=null;
		csParser.type_return type823 = default(csParser.type_return);
		csParser.identifier_return identifier824 = default(csParser.identifier_return);

		object char_literal822_tree=null;
		object char_literal825_tree=null;

		try { DebugEnterRule(GrammarFileName, "binary_operator_declarator");
		DebugLocation(815, 31);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 231)) { return retval; }
			// cs.g:815:34: ( ',' type identifier ')' )
			DebugEnterAlt(1);
			// cs.g:816:2: ',' type identifier ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(816, 2);
			char_literal822=(IToken)Match(input,91,Follow._91_in_binary_operator_declarator6484); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal822_tree = (object)adaptor.Create(char_literal822);
			adaptor.AddChild(root_0, char_literal822_tree);
			}
			DebugLocation(816, 8);
			PushFollow(Follow._type_in_binary_operator_declarator6488);
			type823=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type823.Tree);
			DebugLocation(816, 15);
			PushFollow(Follow._identifier_in_binary_operator_declarator6492);
			identifier824=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier824.Tree);
			DebugLocation(816, 28);
			char_literal825=(IToken)Match(input,RPAREN,Follow._RPAREN_in_binary_operator_declarator6496); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal825_tree = (object)adaptor.Create(char_literal825);
			adaptor.AddChild(root_0, char_literal825_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("binary_operator_declarator", 231);
			LeaveRule("binary_operator_declarator", 231);
			Leave_binary_operator_declarator();
			if (state.backtracking > 0) { Memoize(input, 231, binary_operator_declarator_StartIndex); }
		}
		DebugLocation(816, 31);
		} finally { DebugExitRule(GrammarFileName, "binary_operator_declarator"); }
		return retval;

	}
	// $ANTLR end "binary_operator_declarator"

	public class overloadable_binary_operator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_overloadable_binary_operator();
	partial void Leave_overloadable_binary_operator();

	// $ANTLR start "overloadable_binary_operator"
	// cs.g:818:8: public overloadable_binary_operator : ( '*' | '/' | '%' | '&' | '|' | '^' | '<<' | '>' '>' | '==' | '!=' | '>' | '<' | '>=' | '<=' );
	[GrammarRule("overloadable_binary_operator")]
	public csParser.overloadable_binary_operator_return overloadable_binary_operator()
	{
		Enter_overloadable_binary_operator();
		EnterRule("overloadable_binary_operator", 232);
		TraceIn("overloadable_binary_operator", 232);
		csParser.overloadable_binary_operator_return retval = new csParser.overloadable_binary_operator_return();
		retval.Start = (IToken)input.LT(1);
		int overloadable_binary_operator_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal826=null;
		IToken char_literal827=null;
		IToken char_literal828=null;
		IToken char_literal829=null;
		IToken char_literal830=null;
		IToken char_literal831=null;
		IToken string_literal832=null;
		IToken char_literal833=null;
		IToken char_literal834=null;
		IToken string_literal835=null;
		IToken string_literal836=null;
		IToken char_literal837=null;
		IToken char_literal838=null;
		IToken string_literal839=null;
		IToken string_literal840=null;

		object char_literal826_tree=null;
		object char_literal827_tree=null;
		object char_literal828_tree=null;
		object char_literal829_tree=null;
		object char_literal830_tree=null;
		object char_literal831_tree=null;
		object string_literal832_tree=null;
		object char_literal833_tree=null;
		object char_literal834_tree=null;
		object string_literal835_tree=null;
		object string_literal836_tree=null;
		object char_literal837_tree=null;
		object char_literal838_tree=null;
		object string_literal839_tree=null;
		object string_literal840_tree=null;

		try { DebugEnterRule(GrammarFileName, "overloadable_binary_operator");
		DebugLocation(818, 109);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 232)) { return retval; }
			// cs.g:818:36: ( '*' | '/' | '%' | '&' | '|' | '^' | '<<' | '>' '>' | '==' | '!=' | '>' | '<' | '>=' | '<=' )
			int alt231=14;
			try { DebugEnterDecision(231, decisionCanBacktrack[231]);
			try
			{
				alt231 = dfa231.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(231); }
			switch (alt231)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:819:19: '*'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 19);
				char_literal826=(IToken)Match(input,102,Follow._102_in_overloadable_binary_operator6509); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal826_tree = (object)adaptor.Create(char_literal826);
				adaptor.AddChild(root_0, char_literal826_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:819:25: '/'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 25);
				char_literal827=(IToken)Match(input,118,Follow._118_in_overloadable_binary_operator6513); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal827_tree = (object)adaptor.Create(char_literal827);
				adaptor.AddChild(root_0, char_literal827_tree);
				}

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:819:31: '%'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 31);
				char_literal828=(IToken)Match(input,119,Follow._119_in_overloadable_binary_operator6517); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal828_tree = (object)adaptor.Create(char_literal828);
				adaptor.AddChild(root_0, char_literal828_tree);
				}

				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:819:37: '&'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 37);
				char_literal829=(IToken)Match(input,117,Follow._117_in_overloadable_binary_operator6521); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal829_tree = (object)adaptor.Create(char_literal829);
				adaptor.AddChild(root_0, char_literal829_tree);
				}

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:819:43: '|'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 43);
				char_literal830=(IToken)Match(input,127,Follow._127_in_overloadable_binary_operator6525); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal830_tree = (object)adaptor.Create(char_literal830);
				adaptor.AddChild(root_0, char_literal830_tree);
				}

				}
				break;
			case 6:
				DebugEnterAlt(6);
				// cs.g:819:49: '^'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 49);
				char_literal831=(IToken)Match(input,126,Follow._126_in_overloadable_binary_operator6529); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal831_tree = (object)adaptor.Create(char_literal831);
				adaptor.AddChild(root_0, char_literal831_tree);
				}

				}
				break;
			case 7:
				DebugEnterAlt(7);
				// cs.g:819:55: '<<'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 55);
				string_literal832=(IToken)Match(input,120,Follow._120_in_overloadable_binary_operator6533); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal832_tree = (object)adaptor.Create(string_literal832);
				adaptor.AddChild(root_0, string_literal832_tree);
				}

				}
				break;
			case 8:
				DebugEnterAlt(8);
				// cs.g:819:62: '>' '>'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 62);
				char_literal833=(IToken)Match(input,GT,Follow._GT_in_overloadable_binary_operator6537); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal833_tree = (object)adaptor.Create(char_literal833);
				adaptor.AddChild(root_0, char_literal833_tree);
				}
				DebugLocation(819, 66);
				char_literal834=(IToken)Match(input,GT,Follow._GT_in_overloadable_binary_operator6539); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal834_tree = (object)adaptor.Create(char_literal834);
				adaptor.AddChild(root_0, char_literal834_tree);
				}

				}
				break;
			case 9:
				DebugEnterAlt(9);
				// cs.g:819:72: '=='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 72);
				string_literal835=(IToken)Match(input,124,Follow._124_in_overloadable_binary_operator6543); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal835_tree = (object)adaptor.Create(string_literal835);
				adaptor.AddChild(root_0, string_literal835_tree);
				}

				}
				break;
			case 10:
				DebugEnterAlt(10);
				// cs.g:819:79: '!='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 79);
				string_literal836=(IToken)Match(input,125,Follow._125_in_overloadable_binary_operator6547); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal836_tree = (object)adaptor.Create(string_literal836);
				adaptor.AddChild(root_0, string_literal836_tree);
				}

				}
				break;
			case 11:
				DebugEnterAlt(11);
				// cs.g:819:86: '>'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 86);
				char_literal837=(IToken)Match(input,GT,Follow._GT_in_overloadable_binary_operator6551); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal837_tree = (object)adaptor.Create(char_literal837);
				adaptor.AddChild(root_0, char_literal837_tree);
				}

				}
				break;
			case 12:
				DebugEnterAlt(12);
				// cs.g:819:92: '<'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 92);
				char_literal838=(IToken)Match(input,101,Follow._101_in_overloadable_binary_operator6555); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal838_tree = (object)adaptor.Create(char_literal838);
				adaptor.AddChild(root_0, char_literal838_tree);
				}

				}
				break;
			case 13:
				DebugEnterAlt(13);
				// cs.g:819:98: '>='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 98);
				string_literal839=(IToken)Match(input,116,Follow._116_in_overloadable_binary_operator6559); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal839_tree = (object)adaptor.Create(string_literal839);
				adaptor.AddChild(root_0, string_literal839_tree);
				}

				}
				break;
			case 14:
				DebugEnterAlt(14);
				// cs.g:819:105: '<='
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(819, 105);
				string_literal840=(IToken)Match(input,121,Follow._121_in_overloadable_binary_operator6563); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal840_tree = (object)adaptor.Create(string_literal840);
				adaptor.AddChild(root_0, string_literal840_tree);
				}

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("overloadable_binary_operator", 232);
			LeaveRule("overloadable_binary_operator", 232);
			Leave_overloadable_binary_operator();
			if (state.backtracking > 0) { Memoize(input, 232, overloadable_binary_operator_StartIndex); }
		}
		DebugLocation(819, 109);
		} finally { DebugExitRule(GrammarFileName, "overloadable_binary_operator"); }
		return retval;

	}
	// $ANTLR end "overloadable_binary_operator"

	public class conversion_operator_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_conversion_operator_declaration();
	partial void Leave_conversion_operator_declaration();

	// $ANTLR start "conversion_operator_declaration"
	// cs.g:821:8: public conversion_operator_declaration : conversion_operator_declarator operator_body ;
	[GrammarRule("conversion_operator_declaration")]
	public csParser.conversion_operator_declaration_return conversion_operator_declaration()
	{
		Enter_conversion_operator_declaration();
		EnterRule("conversion_operator_declaration", 233);
		TraceIn("conversion_operator_declaration", 233);
		csParser.conversion_operator_declaration_return retval = new csParser.conversion_operator_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int conversion_operator_declaration_StartIndex = input.Index;
		object root_0 = null;

		csParser.conversion_operator_declarator_return conversion_operator_declarator841 = default(csParser.conversion_operator_declarator_return);
		csParser.operator_body_return operator_body842 = default(csParser.operator_body_return);


		try { DebugEnterRule(GrammarFileName, "conversion_operator_declaration");
		DebugLocation(821, 48);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 233)) { return retval; }
			// cs.g:821:39: ( conversion_operator_declarator operator_body )
			DebugEnterAlt(1);
			// cs.g:822:2: conversion_operator_declarator operator_body
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(822, 2);
			PushFollow(Follow._conversion_operator_declarator_in_conversion_operator_declaration6575);
			conversion_operator_declarator841=conversion_operator_declarator();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conversion_operator_declarator841.Tree);
			DebugLocation(822, 35);
			PushFollow(Follow._operator_body_in_conversion_operator_declaration6579);
			operator_body842=operator_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, operator_body842.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("conversion_operator_declaration", 233);
			LeaveRule("conversion_operator_declaration", 233);
			Leave_conversion_operator_declaration();
			if (state.backtracking > 0) { Memoize(input, 233, conversion_operator_declaration_StartIndex); }
		}
		DebugLocation(822, 48);
		} finally { DebugExitRule(GrammarFileName, "conversion_operator_declaration"); }
		return retval;

	}
	// $ANTLR end "conversion_operator_declaration"

	public class conversion_operator_declarator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_conversion_operator_declarator();
	partial void Leave_conversion_operator_declarator();

	// $ANTLR start "conversion_operator_declarator"
	// cs.g:823:8: public conversion_operator_declarator : ( 'implicit' | 'explicit' ) 'operator' type '(' type identifier ')' ;
	[GrammarRule("conversion_operator_declarator")]
	public csParser.conversion_operator_declarator_return conversion_operator_declarator()
	{
		Enter_conversion_operator_declarator();
		EnterRule("conversion_operator_declarator", 234);
		TraceIn("conversion_operator_declarator", 234);
		csParser.conversion_operator_declarator_return retval = new csParser.conversion_operator_declarator_return();
		retval.Start = (IToken)input.LT(1);
		int conversion_operator_declarator_StartIndex = input.Index;
		object root_0 = null;

		IToken set843=null;
		IToken string_literal844=null;
		IToken char_literal846=null;
		IToken char_literal849=null;
		csParser.type_return type845 = default(csParser.type_return);
		csParser.type_return type847 = default(csParser.type_return);
		csParser.identifier_return identifier848 = default(csParser.identifier_return);

		object set843_tree=null;
		object string_literal844_tree=null;
		object char_literal846_tree=null;
		object char_literal849_tree=null;

		try { DebugEnterRule(GrammarFileName, "conversion_operator_declarator");
		DebugLocation(823, 78);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 234)) { return retval; }
			// cs.g:823:38: ( ( 'implicit' | 'explicit' ) 'operator' type '(' type identifier ')' )
			DebugEnterAlt(1);
			// cs.g:824:2: ( 'implicit' | 'explicit' ) 'operator' type '(' type identifier ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(824, 2);
			set843=(IToken)input.LT(1);
			if ((input.LA(1)>=174 && input.LA(1)<=175))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set843));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}

			DebugLocation(824, 29);
			string_literal844=(IToken)Match(input,173,Follow._173_in_conversion_operator_declarator6598); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal844_tree = (object)adaptor.Create(string_literal844);
			adaptor.AddChild(root_0, string_literal844_tree);
			}
			DebugLocation(824, 42);
			PushFollow(Follow._type_in_conversion_operator_declarator6602);
			type845=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type845.Tree);
			DebugLocation(824, 49);
			char_literal846=(IToken)Match(input,90,Follow._90_in_conversion_operator_declarator6606); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal846_tree = (object)adaptor.Create(char_literal846);
			adaptor.AddChild(root_0, char_literal846_tree);
			}
			DebugLocation(824, 55);
			PushFollow(Follow._type_in_conversion_operator_declarator6610);
			type847=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type847.Tree);
			DebugLocation(824, 62);
			PushFollow(Follow._identifier_in_conversion_operator_declarator6614);
			identifier848=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier848.Tree);
			DebugLocation(824, 75);
			char_literal849=(IToken)Match(input,RPAREN,Follow._RPAREN_in_conversion_operator_declarator6618); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal849_tree = (object)adaptor.Create(char_literal849);
			adaptor.AddChild(root_0, char_literal849_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("conversion_operator_declarator", 234);
			LeaveRule("conversion_operator_declarator", 234);
			Leave_conversion_operator_declarator();
			if (state.backtracking > 0) { Memoize(input, 234, conversion_operator_declarator_StartIndex); }
		}
		DebugLocation(824, 78);
		} finally { DebugExitRule(GrammarFileName, "conversion_operator_declarator"); }
		return retval;

	}
	// $ANTLR end "conversion_operator_declarator"

	public class operator_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_operator_body();
	partial void Leave_operator_body();

	// $ANTLR start "operator_body"
	// cs.g:825:8: public operator_body : block ;
	[GrammarRule("operator_body")]
	public csParser.operator_body_return operator_body()
	{
		Enter_operator_body();
		EnterRule("operator_body", 235);
		TraceIn("operator_body", 235);
		csParser.operator_body_return retval = new csParser.operator_body_return();
		retval.Start = (IToken)input.LT(1);
		int operator_body_StartIndex = input.Index;
		object root_0 = null;

		csParser.block_return block850 = default(csParser.block_return);


		try { DebugEnterRule(GrammarFileName, "operator_body");
		DebugLocation(825, 7);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 235)) { return retval; }
			// cs.g:825:21: ( block )
			DebugEnterAlt(1);
			// cs.g:826:2: block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(826, 2);
			PushFollow(Follow._block_in_operator_body6628);
			block850=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block850.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("operator_body", 235);
			LeaveRule("operator_body", 235);
			Leave_operator_body();
			if (state.backtracking > 0) { Memoize(input, 235, operator_body_StartIndex); }
		}
		DebugLocation(826, 7);
		} finally { DebugExitRule(GrammarFileName, "operator_body"); }
		return retval;

	}
	// $ANTLR end "operator_body"

	public class constructor_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_constructor_declaration();
	partial void Leave_constructor_declaration();

	// $ANTLR start "constructor_declaration"
	// cs.g:829:8: public constructor_declaration : constructor_declarator constructor_body ;
	[GrammarRule("constructor_declaration")]
	public csParser.constructor_declaration_return constructor_declaration()
	{
		Enter_constructor_declaration();
		EnterRule("constructor_declaration", 236);
		TraceIn("constructor_declaration", 236);
		csParser.constructor_declaration_return retval = new csParser.constructor_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int constructor_declaration_StartIndex = input.Index;
		object root_0 = null;

		csParser.constructor_declarator_return constructor_declarator851 = default(csParser.constructor_declarator_return);
		csParser.constructor_body_return constructor_body852 = default(csParser.constructor_body_return);


		try { DebugEnterRule(GrammarFileName, "constructor_declaration");
		DebugLocation(829, 43);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 236)) { return retval; }
			// cs.g:829:31: ( constructor_declarator constructor_body )
			DebugEnterAlt(1);
			// cs.g:830:2: constructor_declarator constructor_body
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(830, 2);
			PushFollow(Follow._constructor_declarator_in_constructor_declaration6640);
			constructor_declarator851=constructor_declarator();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_declarator851.Tree);
			DebugLocation(830, 27);
			PushFollow(Follow._constructor_body_in_constructor_declaration6644);
			constructor_body852=constructor_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_body852.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("constructor_declaration", 236);
			LeaveRule("constructor_declaration", 236);
			Leave_constructor_declaration();
			if (state.backtracking > 0) { Memoize(input, 236, constructor_declaration_StartIndex); }
		}
		DebugLocation(830, 43);
		} finally { DebugExitRule(GrammarFileName, "constructor_declaration"); }
		return retval;

	}
	// $ANTLR end "constructor_declaration"

	public class constructor_declarator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_constructor_declarator();
	partial void Leave_constructor_declarator();

	// $ANTLR start "constructor_declarator"
	// cs.g:831:8: public constructor_declarator : identifier '(' ( formal_parameter_list )? ')' ( constructor_initializer )? ;
	[GrammarRule("constructor_declarator")]
	public csParser.constructor_declarator_return constructor_declarator()
	{
		Enter_constructor_declarator();
		EnterRule("constructor_declarator", 237);
		TraceIn("constructor_declarator", 237);
		csParser.constructor_declarator_return retval = new csParser.constructor_declarator_return();
		retval.Start = (IToken)input.LT(1);
		int constructor_declarator_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal854=null;
		IToken char_literal856=null;
		csParser.identifier_return identifier853 = default(csParser.identifier_return);
		csParser.formal_parameter_list_return formal_parameter_list855 = default(csParser.formal_parameter_list_return);
		csParser.constructor_initializer_return constructor_initializer857 = default(csParser.constructor_initializer_return);

		object char_literal854_tree=null;
		object char_literal856_tree=null;

		try { DebugEnterRule(GrammarFileName, "constructor_declarator");
		DebugLocation(831, 76);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 237)) { return retval; }
			// cs.g:831:30: ( identifier '(' ( formal_parameter_list )? ')' ( constructor_initializer )? )
			DebugEnterAlt(1);
			// cs.g:832:2: identifier '(' ( formal_parameter_list )? ')' ( constructor_initializer )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(832, 2);
			PushFollow(Follow._identifier_in_constructor_declarator6654);
			identifier853=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier853.Tree);
			DebugLocation(832, 15);
			char_literal854=(IToken)Match(input,90,Follow._90_in_constructor_declarator6658); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal854_tree = (object)adaptor.Create(char_literal854);
			adaptor.AddChild(root_0, char_literal854_tree);
			}
			DebugLocation(832, 21);
			// cs.g:832:21: ( formal_parameter_list )?
			int alt232=2;
			try { DebugEnterSubRule(232);
			try { DebugEnterDecision(232, decisionCanBacktrack[232]);
			int LA232_0 = input.LA(1);

			if ((LA232_0==IDENTIFIER||(LA232_0>=ELIF && LA232_0<=UNDEF)||LA232_0==65||(LA232_0>=82 && LA232_0<=83)||LA232_0==88||(LA232_0>=93 && LA232_0<=94)||(LA232_0>=132 && LA232_0<=133)||(LA232_0>=135 && LA232_0<=148)||(LA232_0>=150 && LA232_0<=152)||LA232_0==154||(LA232_0>=156 && LA232_0<=168)||(LA232_0>=170 && LA232_0<=171)||(LA232_0>=177 && LA232_0<=178)||(LA232_0>=195 && LA232_0<=202)))
			{
				alt232=1;
			}
			} finally { DebugExitDecision(232); }
			switch (alt232)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:832:21: formal_parameter_list
				{
				DebugLocation(832, 21);
				PushFollow(Follow._formal_parameter_list_in_constructor_declarator6662);
				formal_parameter_list855=formal_parameter_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list855.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(232); }

			DebugLocation(832, 46);
			char_literal856=(IToken)Match(input,RPAREN,Follow._RPAREN_in_constructor_declarator6667); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal856_tree = (object)adaptor.Create(char_literal856);
			adaptor.AddChild(root_0, char_literal856_tree);
			}
			DebugLocation(832, 52);
			// cs.g:832:52: ( constructor_initializer )?
			int alt233=2;
			try { DebugEnterSubRule(233);
			try { DebugEnterDecision(233, decisionCanBacktrack[233]);
			int LA233_0 = input.LA(1);

			if ((LA233_0==92))
			{
				alt233=1;
			}
			} finally { DebugExitDecision(233); }
			switch (alt233)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:832:52: constructor_initializer
				{
				DebugLocation(832, 52);
				PushFollow(Follow._constructor_initializer_in_constructor_declarator6671);
				constructor_initializer857=constructor_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_initializer857.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(233); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("constructor_declarator", 237);
			LeaveRule("constructor_declarator", 237);
			Leave_constructor_declarator();
			if (state.backtracking > 0) { Memoize(input, 237, constructor_declarator_StartIndex); }
		}
		DebugLocation(832, 76);
		} finally { DebugExitRule(GrammarFileName, "constructor_declarator"); }
		return retval;

	}
	// $ANTLR end "constructor_declarator"

	public class constructor_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_constructor_initializer();
	partial void Leave_constructor_initializer();

	// $ANTLR start "constructor_initializer"
	// cs.g:833:8: public constructor_initializer : ':' ( 'base' | 'this' ) '(' ( argument_list )? ')' ;
	[GrammarRule("constructor_initializer")]
	public csParser.constructor_initializer_return constructor_initializer()
	{
		Enter_constructor_initializer();
		EnterRule("constructor_initializer", 238);
		TraceIn("constructor_initializer", 238);
		csParser.constructor_initializer_return retval = new csParser.constructor_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int constructor_initializer_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal858=null;
		IToken set859=null;
		IToken char_literal860=null;
		IToken char_literal862=null;
		csParser.argument_list_return argument_list861 = default(csParser.argument_list_return);

		object char_literal858_tree=null;
		object set859_tree=null;
		object char_literal860_tree=null;
		object char_literal862_tree=null;

		try { DebugEnterRule(GrammarFileName, "constructor_initializer");
		DebugLocation(833, 54);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 238)) { return retval; }
			// cs.g:833:31: ( ':' ( 'base' | 'this' ) '(' ( argument_list )? ')' )
			DebugEnterAlt(1);
			// cs.g:834:2: ':' ( 'base' | 'this' ) '(' ( argument_list )? ')'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(834, 2);
			char_literal858=(IToken)Match(input,92,Follow._92_in_constructor_initializer6682); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal858_tree = (object)adaptor.Create(char_literal858);
			adaptor.AddChild(root_0, char_literal858_tree);
			}
			DebugLocation(834, 8);
			set859=(IToken)input.LT(1);
			if ((input.LA(1)>=83 && input.LA(1)<=84))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set859));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}

			DebugLocation(834, 28);
			char_literal860=(IToken)Match(input,90,Follow._90_in_constructor_initializer6696); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal860_tree = (object)adaptor.Create(char_literal860);
			adaptor.AddChild(root_0, char_literal860_tree);
			}
			DebugLocation(834, 34);
			// cs.g:834:34: ( argument_list )?
			int alt234=2;
			try { DebugEnterSubRule(234);
			try { DebugEnterDecision(234, decisionCanBacktrack[234]);
			int LA234_0 = input.LA(1);

			if (((LA234_0>=IDENTIFIER && LA234_0<=NULL)||LA234_0==MINUS||(LA234_0>=ELIF && LA234_0<=UNDEF)||LA234_0==65||LA234_0==68||(LA234_0>=83 && LA234_0<=84)||(LA234_0>=86 && LA234_0<=87)||LA234_0==90||(LA234_0>=93 && LA234_0<=100)||LA234_0==102||(LA234_0>=104 && LA234_0<=106)||LA234_0==117||(LA234_0>=132 && LA234_0<=133)||(LA234_0>=135 && LA234_0<=148)||(LA234_0>=150 && LA234_0<=152)||LA234_0==154||(LA234_0>=156 && LA234_0<=168)||LA234_0==170||(LA234_0>=177 && LA234_0<=178)||(LA234_0>=195 && LA234_0<=202)))
			{
				alt234=1;
			}
			} finally { DebugExitDecision(234); }
			switch (alt234)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:834:34: argument_list
				{
				DebugLocation(834, 34);
				PushFollow(Follow._argument_list_in_constructor_initializer6700);
				argument_list861=argument_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_list861.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(234); }

			DebugLocation(834, 51);
			char_literal862=(IToken)Match(input,RPAREN,Follow._RPAREN_in_constructor_initializer6705); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal862_tree = (object)adaptor.Create(char_literal862);
			adaptor.AddChild(root_0, char_literal862_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("constructor_initializer", 238);
			LeaveRule("constructor_initializer", 238);
			Leave_constructor_initializer();
			if (state.backtracking > 0) { Memoize(input, 238, constructor_initializer_StartIndex); }
		}
		DebugLocation(834, 54);
		} finally { DebugExitRule(GrammarFileName, "constructor_initializer"); }
		return retval;

	}
	// $ANTLR end "constructor_initializer"

	public class constructor_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_constructor_body();
	partial void Leave_constructor_body();

	// $ANTLR start "constructor_body"
	// cs.g:835:8: public constructor_body : block ;
	[GrammarRule("constructor_body")]
	public csParser.constructor_body_return constructor_body()
	{
		Enter_constructor_body();
		EnterRule("constructor_body", 239);
		TraceIn("constructor_body", 239);
		csParser.constructor_body_return retval = new csParser.constructor_body_return();
		retval.Start = (IToken)input.LT(1);
		int constructor_body_StartIndex = input.Index;
		object root_0 = null;

		csParser.block_return block863 = default(csParser.block_return);


		try { DebugEnterRule(GrammarFileName, "constructor_body");
		DebugLocation(835, 7);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 239)) { return retval; }
			// cs.g:835:24: ( block )
			DebugEnterAlt(1);
			// cs.g:836:2: block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(836, 2);
			PushFollow(Follow._block_in_constructor_body6715);
			block863=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block863.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("constructor_body", 239);
			LeaveRule("constructor_body", 239);
			Leave_constructor_body();
			if (state.backtracking > 0) { Memoize(input, 239, constructor_body_StartIndex); }
		}
		DebugLocation(836, 7);
		} finally { DebugExitRule(GrammarFileName, "constructor_body"); }
		return retval;

	}
	// $ANTLR end "constructor_body"

	public class destructor_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_destructor_declaration();
	partial void Leave_destructor_declaration();

	// $ANTLR start "destructor_declaration"
	// cs.g:845:8: public destructor_declaration : '~' identifier '(' ')' destructor_body ;
	[GrammarRule("destructor_declaration")]
	public csParser.destructor_declaration_return destructor_declaration()
	{
		Enter_destructor_declaration();
		EnterRule("destructor_declaration", 240);
		TraceIn("destructor_declaration", 240);
		csParser.destructor_declaration_return retval = new csParser.destructor_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int destructor_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal864=null;
		IToken char_literal866=null;
		IToken char_literal867=null;
		csParser.identifier_return identifier865 = default(csParser.identifier_return);
		csParser.destructor_body_return destructor_body868 = default(csParser.destructor_body_return);

		object char_literal864_tree=null;
		object char_literal866_tree=null;
		object char_literal867_tree=null;

		try { DebugEnterRule(GrammarFileName, "destructor_declaration");
		DebugLocation(845, 48);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 240)) { return retval; }
			// cs.g:845:30: ( '~' identifier '(' ')' destructor_body )
			DebugEnterAlt(1);
			// cs.g:846:2: '~' identifier '(' ')' destructor_body
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(846, 2);
			char_literal864=(IToken)Match(input,106,Follow._106_in_destructor_declaration6733); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal864_tree = (object)adaptor.Create(char_literal864);
			adaptor.AddChild(root_0, char_literal864_tree);
			}
			DebugLocation(846, 7);
			PushFollow(Follow._identifier_in_destructor_declaration6736);
			identifier865=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier865.Tree);
			DebugLocation(846, 20);
			char_literal866=(IToken)Match(input,90,Follow._90_in_destructor_declaration6740); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal866_tree = (object)adaptor.Create(char_literal866);
			adaptor.AddChild(root_0, char_literal866_tree);
			}
			DebugLocation(846, 26);
			char_literal867=(IToken)Match(input,RPAREN,Follow._RPAREN_in_destructor_declaration6744); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal867_tree = (object)adaptor.Create(char_literal867);
			adaptor.AddChild(root_0, char_literal867_tree);
			}
			DebugLocation(846, 33);
			PushFollow(Follow._destructor_body_in_destructor_declaration6749);
			destructor_body868=destructor_body();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, destructor_body868.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("destructor_declaration", 240);
			LeaveRule("destructor_declaration", 240);
			Leave_destructor_declaration();
			if (state.backtracking > 0) { Memoize(input, 240, destructor_declaration_StartIndex); }
		}
		DebugLocation(846, 48);
		} finally { DebugExitRule(GrammarFileName, "destructor_declaration"); }
		return retval;

	}
	// $ANTLR end "destructor_declaration"

	public class destructor_body_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_destructor_body();
	partial void Leave_destructor_body();

	// $ANTLR start "destructor_body"
	// cs.g:847:8: public destructor_body : block ;
	[GrammarRule("destructor_body")]
	public csParser.destructor_body_return destructor_body()
	{
		Enter_destructor_body();
		EnterRule("destructor_body", 241);
		TraceIn("destructor_body", 241);
		csParser.destructor_body_return retval = new csParser.destructor_body_return();
		retval.Start = (IToken)input.LT(1);
		int destructor_body_StartIndex = input.Index;
		object root_0 = null;

		csParser.block_return block869 = default(csParser.block_return);


		try { DebugEnterRule(GrammarFileName, "destructor_body");
		DebugLocation(847, 7);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 241)) { return retval; }
			// cs.g:847:23: ( block )
			DebugEnterAlt(1);
			// cs.g:848:2: block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(848, 2);
			PushFollow(Follow._block_in_destructor_body6759);
			block869=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block869.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("destructor_body", 241);
			LeaveRule("destructor_body", 241);
			Leave_destructor_body();
			if (state.backtracking > 0) { Memoize(input, 241, destructor_body_StartIndex); }
		}
		DebugLocation(848, 7);
		} finally { DebugExitRule(GrammarFileName, "destructor_body"); }
		return retval;

	}
	// $ANTLR end "destructor_body"

	public class invocation_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_invocation_expression();
	partial void Leave_invocation_expression();

	// $ANTLR start "invocation_expression"
	// cs.g:851:8: public invocation_expression : invocation_start ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ;
	[GrammarRule("invocation_expression")]
	public csParser.invocation_expression_return invocation_expression()
	{
		Enter_invocation_expression();
		EnterRule("invocation_expression", 242);
		TraceIn("invocation_expression", 242);
		csParser.invocation_expression_return retval = new csParser.invocation_expression_return();
		retval.Start = (IToken)input.LT(1);
		int invocation_expression_StartIndex = input.Index;
		object root_0 = null;

		csParser.invocation_start_return invocation_start870 = default(csParser.invocation_start_return);
		csParser.arguments_return arguments871 = default(csParser.arguments_return);
		csParser.invocation_part_return invocation_part872 = default(csParser.invocation_part_return);
		csParser.invocation_part_return invocation_part873 = default(csParser.invocation_part_return);
		csParser.arguments_return arguments874 = default(csParser.arguments_return);


		try { DebugEnterRule(GrammarFileName, "invocation_expression");
		DebugLocation(851, 38);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 242)) { return retval; }
			// cs.g:851:29: ( invocation_start ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments )
			DebugEnterAlt(1);
			// cs.g:852:2: invocation_start ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(852, 2);
			PushFollow(Follow._invocation_start_in_invocation_expression6771);
			invocation_start870=invocation_start();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_start870.Tree);
			DebugLocation(852, 21);
			// cs.g:852:21: ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )*
			try { DebugEnterSubRule(235);
			while (true)
			{
				int alt235=3;
				try { DebugEnterDecision(235, decisionCanBacktrack[235]);
				int LA235_0 = input.LA(1);

				if ((LA235_0==90))
				{
					int LA235_1 = input.LA(2);

					if ((EvaluatePredicate(synpred31_cs_fragment)))
					{
						alt235=1;
					}


				}
				else if (((LA235_0>=DOT && LA235_0<=PTR)||LA235_0==88))
				{
					alt235=2;
				}


				} finally { DebugExitDecision(235); }
				switch ( alt235 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:852:22: ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part )
					{
					DebugLocation(852, 22);
					// cs.g:852:22: ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part )
					DebugEnterAlt(1);
					// cs.g:852:23: ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part
					{
					DebugLocation(852, 55);
					PushFollow(Follow._arguments_in_invocation_expression6793);
					arguments871=arguments();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments871.Tree);
					DebugLocation(852, 67);
					PushFollow(Follow._invocation_part_in_invocation_expression6797);
					invocation_part872=invocation_part();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_part872.Tree);

					}


					}
					break;
				case 2:
					DebugEnterAlt(2);
					// cs.g:853:9: invocation_part
					{
					DebugLocation(853, 9);
					PushFollow(Follow._invocation_part_in_invocation_expression6808);
					invocation_part873=invocation_part();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_part873.Tree);

					}
					break;

				default:
					goto loop235;
				}
			}

			loop235:
				;

			} finally { DebugExitSubRule(235); }

			DebugLocation(853, 29);
			PushFollow(Follow._arguments_in_invocation_expression6814);
			arguments874=arguments();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments874.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("invocation_expression", 242);
			LeaveRule("invocation_expression", 242);
			Leave_invocation_expression();
			if (state.backtracking > 0) { Memoize(input, 242, invocation_expression_StartIndex); }
		}
		DebugLocation(853, 38);
		} finally { DebugExitRule(GrammarFileName, "invocation_expression"); }
		return retval;

	}
	// $ANTLR end "invocation_expression"

	public class invocation_start_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_invocation_start();
	partial void Leave_invocation_start();

	// $ANTLR start "invocation_start"
	// cs.g:854:8: public invocation_start : ( predefined_type | ( identifier generic_argument_list )=> identifier generic_argument_list | 'this' | 'base' | identifier ( '::' identifier )? | typeof_expression );
	[GrammarRule("invocation_start")]
	public csParser.invocation_start_return invocation_start()
	{
		Enter_invocation_start();
		EnterRule("invocation_start", 243);
		TraceIn("invocation_start", 243);
		csParser.invocation_start_return retval = new csParser.invocation_start_return();
		retval.Start = (IToken)input.LT(1);
		int invocation_start_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal878=null;
		IToken string_literal879=null;
		IToken string_literal881=null;
		csParser.predefined_type_return predefined_type875 = default(csParser.predefined_type_return);
		csParser.identifier_return identifier876 = default(csParser.identifier_return);
		csParser.generic_argument_list_return generic_argument_list877 = default(csParser.generic_argument_list_return);
		csParser.identifier_return identifier880 = default(csParser.identifier_return);
		csParser.identifier_return identifier882 = default(csParser.identifier_return);
		csParser.typeof_expression_return typeof_expression883 = default(csParser.typeof_expression_return);

		object string_literal878_tree=null;
		object string_literal879_tree=null;
		object string_literal881_tree=null;

		try { DebugEnterRule(GrammarFileName, "invocation_start");
		DebugLocation(854, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 243)) { return retval; }
			// cs.g:854:24: ( predefined_type | ( identifier generic_argument_list )=> identifier generic_argument_list | 'this' | 'base' | identifier ( '::' identifier )? | typeof_expression )
			int alt237=6;
			try { DebugEnterDecision(237, decisionCanBacktrack[237]);
			switch (input.LA(1))
			{
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 196:
			case 197:
			case 198:
			case 199:
			case 200:
			case 201:
				{
				alt237=1;
				}
				break;
			case IDENTIFIER:
				{
				int LA237_2 = input.LA(2);

				if ((LA237_2==101) && (EvaluatePredicate(synpred32_cs_fragment)))
				{
					alt237=2;
				}
				else if (((LA237_2>=DOT && LA237_2<=PTR)||LA237_2==85||LA237_2==88||LA237_2==90))
				{
					alt237=5;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 237, 2, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 132:
			case 133:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 170:
			case 177:
			case 178:
			case 195:
			case 202:
				{
				int LA237_3 = input.LA(2);

				if ((LA237_3==101) && (EvaluatePredicate(synpred32_cs_fragment)))
				{
					alt237=2;
				}
				else if (((LA237_3>=DOT && LA237_3<=PTR)||LA237_3==85||LA237_3==88||LA237_3==90))
				{
					alt237=5;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 237, 3, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case 83:
				{
				alt237=3;
				}
				break;
			case 84:
				{
				alt237=4;
				}
				break;
			case 100:
				{
				alt237=6;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 237, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(237); }
			switch (alt237)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:855:2: predefined_type
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(855, 2);
				PushFollow(Follow._predefined_type_in_invocation_start6824);
				predefined_type875=predefined_type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type875.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:856:4: ( identifier generic_argument_list )=> identifier generic_argument_list
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(856, 45);
				PushFollow(Follow._identifier_in_invocation_start6841);
				identifier876=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier876.Tree);
				DebugLocation(856, 58);
				PushFollow(Follow._generic_argument_list_in_invocation_start6845);
				generic_argument_list877=generic_argument_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_argument_list877.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:857:4: 'this'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(857, 4);
				string_literal878=(IToken)Match(input,83,Follow._83_in_invocation_start6850); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal878_tree = (object)adaptor.Create(string_literal878);
				adaptor.AddChild(root_0, string_literal878_tree);
				}

				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:858:4: 'base'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(858, 4);
				string_literal879=(IToken)Match(input,84,Follow._84_in_invocation_start6856); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal879_tree = (object)adaptor.Create(string_literal879);
				adaptor.AddChild(root_0, string_literal879_tree);
				}

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:859:4: identifier ( '::' identifier )?
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(859, 4);
				PushFollow(Follow._identifier_in_invocation_start6861);
				identifier880=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier880.Tree);
				DebugLocation(859, 17);
				// cs.g:859:17: ( '::' identifier )?
				int alt236=2;
				try { DebugEnterSubRule(236);
				try { DebugEnterDecision(236, decisionCanBacktrack[236]);
				int LA236_0 = input.LA(1);

				if ((LA236_0==85))
				{
					alt236=1;
				}
				} finally { DebugExitDecision(236); }
				switch (alt236)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:859:18: '::' identifier
					{
					DebugLocation(859, 18);
					string_literal881=(IToken)Match(input,85,Follow._85_in_invocation_start6866); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					string_literal881_tree = (object)adaptor.Create(string_literal881);
					adaptor.AddChild(root_0, string_literal881_tree);
					}
					DebugLocation(859, 25);
					PushFollow(Follow._identifier_in_invocation_start6870);
					identifier882=identifier();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier882.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(236); }


				}
				break;
			case 6:
				DebugEnterAlt(6);
				// cs.g:860:4: typeof_expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(860, 4);
				PushFollow(Follow._typeof_expression_in_invocation_start6877);
				typeof_expression883=typeof_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, typeof_expression883.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("invocation_start", 243);
			LeaveRule("invocation_start", 243);
			Leave_invocation_start();
			if (state.backtracking > 0) { Memoize(input, 243, invocation_start_StartIndex); }
		}
		DebugLocation(861, 1);
		} finally { DebugExitRule(GrammarFileName, "invocation_start"); }
		return retval;

	}
	// $ANTLR end "invocation_start"

	public class invocation_part_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_invocation_part();
	partial void Leave_invocation_part();

	// $ANTLR start "invocation_part"
	// cs.g:862:8: public invocation_part : ( access_identifier | brackets );
	[GrammarRule("invocation_part")]
	public csParser.invocation_part_return invocation_part()
	{
		Enter_invocation_part();
		EnterRule("invocation_part", 244);
		TraceIn("invocation_part", 244);
		csParser.invocation_part_return retval = new csParser.invocation_part_return();
		retval.Start = (IToken)input.LT(1);
		int invocation_part_StartIndex = input.Index;
		object root_0 = null;

		csParser.access_identifier_return access_identifier884 = default(csParser.access_identifier_return);
		csParser.brackets_return brackets885 = default(csParser.brackets_return);


		try { DebugEnterRule(GrammarFileName, "invocation_part");
		DebugLocation(862, 12);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 244)) { return retval; }
			// cs.g:862:23: ( access_identifier | brackets )
			int alt238=2;
			try { DebugEnterDecision(238, decisionCanBacktrack[238]);
			int LA238_0 = input.LA(1);

			if (((LA238_0>=DOT && LA238_0<=PTR)))
			{
				alt238=1;
			}
			else if ((LA238_0==88))
			{
				alt238=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 238, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(238); }
			switch (alt238)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:863:3: access_identifier
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(863, 3);
				PushFollow(Follow._access_identifier_in_invocation_part6902);
				access_identifier884=access_identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, access_identifier884.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:864:4: brackets
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(864, 4);
				PushFollow(Follow._brackets_in_invocation_part6907);
				brackets885=brackets();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, brackets885.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("invocation_part", 244);
			LeaveRule("invocation_part", 244);
			Leave_invocation_part();
			if (state.backtracking > 0) { Memoize(input, 244, invocation_part_StartIndex); }
		}
		DebugLocation(864, 12);
		} finally { DebugExitRule(GrammarFileName, "invocation_part"); }
		return retval;

	}
	// $ANTLR end "invocation_part"

	public class statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_statement();
	partial void Leave_statement();

	// $ANTLR start "statement"
	// cs.g:868:8: public statement : ( ( declaration_statement )=> declaration_statement | ( identifier ':' )=> labeled_statement | embedded_statement );
	[GrammarRule("statement")]
	public csParser.statement_return statement()
	{
		Enter_statement();
		EnterRule("statement", 245);
		TraceIn("statement", 245);
		csParser.statement_return retval = new csParser.statement_return();
		retval.Start = (IToken)input.LT(1);
		int statement_StartIndex = input.Index;
		object root_0 = null;

		csParser.declaration_statement_return declaration_statement886 = default(csParser.declaration_statement_return);
		csParser.labeled_statement_return labeled_statement887 = default(csParser.labeled_statement_return);
		csParser.embedded_statement_return embedded_statement888 = default(csParser.embedded_statement_return);


		try { DebugEnterRule(GrammarFileName, "statement");
		DebugLocation(868, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 245)) { return retval; }
			// cs.g:868:17: ( ( declaration_statement )=> declaration_statement | ( identifier ':' )=> labeled_statement | embedded_statement )
			int alt239=3;
			try { DebugEnterDecision(239, decisionCanBacktrack[239]);
			try
			{
				alt239 = dfa239.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(239); }
			switch (alt239)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:869:2: ( declaration_statement )=> declaration_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(869, 29);
				PushFollow(Follow._declaration_statement_in_statement6926);
				declaration_statement886=declaration_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, declaration_statement886.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:870:4: ( identifier ':' )=> labeled_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(870, 26);
				PushFollow(Follow._labeled_statement_in_statement6941);
				labeled_statement887=labeled_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, labeled_statement887.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:871:4: embedded_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(871, 4);
				PushFollow(Follow._embedded_statement_in_statement6946);
				embedded_statement888=embedded_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement888.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("statement", 245);
			LeaveRule("statement", 245);
			Leave_statement();
			if (state.backtracking > 0) { Memoize(input, 245, statement_StartIndex); }
		}
		DebugLocation(872, 1);
		} finally { DebugExitRule(GrammarFileName, "statement"); }
		return retval;

	}
	// $ANTLR end "statement"

	public class embedded_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_embedded_statement();
	partial void Leave_embedded_statement();

	// $ANTLR start "embedded_statement"
	// cs.g:873:8: public embedded_statement : ( block | selection_statement | iteration_statement | jump_statement | try_statement | checked_statement | unchecked_statement | lock_statement | using_statement | yield_statement | unsafe_statement | fixed_statement | expression_statement );
	[GrammarRule("embedded_statement")]
	public csParser.embedded_statement_return embedded_statement()
	{
		Enter_embedded_statement();
		EnterRule("embedded_statement", 246);
		TraceIn("embedded_statement", 246);
		csParser.embedded_statement_return retval = new csParser.embedded_statement_return();
		retval.Start = (IToken)input.LT(1);
		int embedded_statement_StartIndex = input.Index;
		object root_0 = null;

		csParser.block_return block889 = default(csParser.block_return);
		csParser.selection_statement_return selection_statement890 = default(csParser.selection_statement_return);
		csParser.iteration_statement_return iteration_statement891 = default(csParser.iteration_statement_return);
		csParser.jump_statement_return jump_statement892 = default(csParser.jump_statement_return);
		csParser.try_statement_return try_statement893 = default(csParser.try_statement_return);
		csParser.checked_statement_return checked_statement894 = default(csParser.checked_statement_return);
		csParser.unchecked_statement_return unchecked_statement895 = default(csParser.unchecked_statement_return);
		csParser.lock_statement_return lock_statement896 = default(csParser.lock_statement_return);
		csParser.using_statement_return using_statement897 = default(csParser.using_statement_return);
		csParser.yield_statement_return yield_statement898 = default(csParser.yield_statement_return);
		csParser.unsafe_statement_return unsafe_statement899 = default(csParser.unsafe_statement_return);
		csParser.fixed_statement_return fixed_statement900 = default(csParser.fixed_statement_return);
		csParser.expression_statement_return expression_statement901 = default(csParser.expression_statement_return);


		try { DebugEnterRule(GrammarFileName, "embedded_statement");
		DebugLocation(873, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 246)) { return retval; }
			// cs.g:873:26: ( block | selection_statement | iteration_statement | jump_statement | try_statement | checked_statement | unchecked_statement | lock_statement | using_statement | yield_statement | unsafe_statement | fixed_statement | expression_statement )
			int alt240=13;
			try { DebugEnterDecision(240, decisionCanBacktrack[240]);
			try
			{
				alt240 = dfa240.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(240); }
			switch (alt240)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:874:2: block
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(874, 2);
				PushFollow(Follow._block_in_embedded_statement6958);
				block889=block();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block889.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:875:4: selection_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(875, 4);
				PushFollow(Follow._selection_statement_in_embedded_statement6963);
				selection_statement890=selection_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, selection_statement890.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:876:4: iteration_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(876, 4);
				PushFollow(Follow._iteration_statement_in_embedded_statement6969);
				iteration_statement891=iteration_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, iteration_statement891.Tree);

				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:877:4: jump_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(877, 4);
				PushFollow(Follow._jump_statement_in_embedded_statement6975);
				jump_statement892=jump_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, jump_statement892.Tree);

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:878:4: try_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(878, 4);
				PushFollow(Follow._try_statement_in_embedded_statement6982);
				try_statement893=try_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, try_statement893.Tree);

				}
				break;
			case 6:
				DebugEnterAlt(6);
				// cs.g:879:4: checked_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(879, 4);
				PushFollow(Follow._checked_statement_in_embedded_statement6987);
				checked_statement894=checked_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, checked_statement894.Tree);

				}
				break;
			case 7:
				DebugEnterAlt(7);
				// cs.g:880:4: unchecked_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(880, 4);
				PushFollow(Follow._unchecked_statement_in_embedded_statement6992);
				unchecked_statement895=unchecked_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unchecked_statement895.Tree);

				}
				break;
			case 8:
				DebugEnterAlt(8);
				// cs.g:881:4: lock_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(881, 4);
				PushFollow(Follow._lock_statement_in_embedded_statement6997);
				lock_statement896=lock_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, lock_statement896.Tree);

				}
				break;
			case 9:
				DebugEnterAlt(9);
				// cs.g:882:4: using_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(882, 4);
				PushFollow(Follow._using_statement_in_embedded_statement7002);
				using_statement897=using_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, using_statement897.Tree);

				}
				break;
			case 10:
				DebugEnterAlt(10);
				// cs.g:883:4: yield_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(883, 4);
				PushFollow(Follow._yield_statement_in_embedded_statement7008);
				yield_statement898=yield_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, yield_statement898.Tree);

				}
				break;
			case 11:
				DebugEnterAlt(11);
				// cs.g:884:4: unsafe_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(884, 4);
				PushFollow(Follow._unsafe_statement_in_embedded_statement7014);
				unsafe_statement899=unsafe_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unsafe_statement899.Tree);

				}
				break;
			case 12:
				DebugEnterAlt(12);
				// cs.g:885:4: fixed_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(885, 4);
				PushFollow(Follow._fixed_statement_in_embedded_statement7019);
				fixed_statement900=fixed_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_statement900.Tree);

				}
				break;
			case 13:
				DebugEnterAlt(13);
				// cs.g:886:4: expression_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(886, 4);
				PushFollow(Follow._expression_statement_in_embedded_statement7024);
				expression_statement901=expression_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression_statement901.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("embedded_statement", 246);
			LeaveRule("embedded_statement", 246);
			Leave_embedded_statement();
			if (state.backtracking > 0) { Memoize(input, 246, embedded_statement_StartIndex); }
		}
		DebugLocation(887, 1);
		} finally { DebugExitRule(GrammarFileName, "embedded_statement"); }
		return retval;

	}
	// $ANTLR end "embedded_statement"

	public class fixed_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_fixed_statement();
	partial void Leave_fixed_statement();

	// $ANTLR start "fixed_statement"
	// cs.g:888:8: public fixed_statement : 'fixed' '(' pointer_type fixed_pointer_declarators ')' embedded_statement ;
	[GrammarRule("fixed_statement")]
	public csParser.fixed_statement_return fixed_statement()
	{
		Enter_fixed_statement();
		EnterRule("fixed_statement", 247);
		TraceIn("fixed_statement", 247);
		csParser.fixed_statement_return retval = new csParser.fixed_statement_return();
		retval.Start = (IToken)input.LT(1);
		int fixed_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal902=null;
		IToken char_literal903=null;
		IToken char_literal906=null;
		csParser.pointer_type_return pointer_type904 = default(csParser.pointer_type_return);
		csParser.fixed_pointer_declarators_return fixed_pointer_declarators905 = default(csParser.fixed_pointer_declarators_return);
		csParser.embedded_statement_return embedded_statement907 = default(csParser.embedded_statement_return);

		object string_literal902_tree=null;
		object char_literal903_tree=null;
		object char_literal906_tree=null;

		try { DebugEnterRule(GrammarFileName, "fixed_statement");
		DebugLocation(888, 83);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 247)) { return retval; }
			// cs.g:888:23: ( 'fixed' '(' pointer_type fixed_pointer_declarators ')' embedded_statement )
			DebugEnterAlt(1);
			// cs.g:889:2: 'fixed' '(' pointer_type fixed_pointer_declarators ')' embedded_statement
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(889, 2);
			string_literal902=(IToken)Match(input,176,Follow._176_in_fixed_statement7036); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal902_tree = (object)adaptor.Create(string_literal902);
			adaptor.AddChild(root_0, string_literal902_tree);
			}
			DebugLocation(889, 12);
			char_literal903=(IToken)Match(input,90,Follow._90_in_fixed_statement7040); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal903_tree = (object)adaptor.Create(char_literal903);
			adaptor.AddChild(root_0, char_literal903_tree);
			}
			DebugLocation(889, 18);
			PushFollow(Follow._pointer_type_in_fixed_statement7044);
			pointer_type904=pointer_type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, pointer_type904.Tree);
			DebugLocation(889, 31);
			PushFollow(Follow._fixed_pointer_declarators_in_fixed_statement7046);
			fixed_pointer_declarators905=fixed_pointer_declarators();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_pointer_declarators905.Tree);
			DebugLocation(889, 59);
			char_literal906=(IToken)Match(input,RPAREN,Follow._RPAREN_in_fixed_statement7050); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal906_tree = (object)adaptor.Create(char_literal906);
			adaptor.AddChild(root_0, char_literal906_tree);
			}
			DebugLocation(889, 65);
			PushFollow(Follow._embedded_statement_in_fixed_statement7054);
			embedded_statement907=embedded_statement();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement907.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("fixed_statement", 247);
			LeaveRule("fixed_statement", 247);
			Leave_fixed_statement();
			if (state.backtracking > 0) { Memoize(input, 247, fixed_statement_StartIndex); }
		}
		DebugLocation(889, 83);
		} finally { DebugExitRule(GrammarFileName, "fixed_statement"); }
		return retval;

	}
	// $ANTLR end "fixed_statement"

	public class fixed_pointer_declarators_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_fixed_pointer_declarators();
	partial void Leave_fixed_pointer_declarators();

	// $ANTLR start "fixed_pointer_declarators"
	// cs.g:890:8: public fixed_pointer_declarators : fixed_pointer_declarator ( ',' fixed_pointer_declarator )* ;
	[GrammarRule("fixed_pointer_declarators")]
	public csParser.fixed_pointer_declarators_return fixed_pointer_declarators()
	{
		Enter_fixed_pointer_declarators();
		EnterRule("fixed_pointer_declarators", 248);
		TraceIn("fixed_pointer_declarators", 248);
		csParser.fixed_pointer_declarators_return retval = new csParser.fixed_pointer_declarators_return();
		retval.Start = (IToken)input.LT(1);
		int fixed_pointer_declarators_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal909=null;
		csParser.fixed_pointer_declarator_return fixed_pointer_declarator908 = default(csParser.fixed_pointer_declarator_return);
		csParser.fixed_pointer_declarator_return fixed_pointer_declarator910 = default(csParser.fixed_pointer_declarator_return);

		object char_literal909_tree=null;

		try { DebugEnterRule(GrammarFileName, "fixed_pointer_declarators");
		DebugLocation(890, 62);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 248)) { return retval; }
			// cs.g:890:33: ( fixed_pointer_declarator ( ',' fixed_pointer_declarator )* )
			DebugEnterAlt(1);
			// cs.g:891:2: fixed_pointer_declarator ( ',' fixed_pointer_declarator )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(891, 2);
			PushFollow(Follow._fixed_pointer_declarator_in_fixed_pointer_declarators7064);
			fixed_pointer_declarator908=fixed_pointer_declarator();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_pointer_declarator908.Tree);
			DebugLocation(891, 29);
			// cs.g:891:29: ( ',' fixed_pointer_declarator )*
			try { DebugEnterSubRule(241);
			while (true)
			{
				int alt241=2;
				try { DebugEnterDecision(241, decisionCanBacktrack[241]);
				int LA241_0 = input.LA(1);

				if ((LA241_0==91))
				{
					alt241=1;
				}


				} finally { DebugExitDecision(241); }
				switch ( alt241 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:891:30: ',' fixed_pointer_declarator
					{
					DebugLocation(891, 30);
					char_literal909=(IToken)Match(input,91,Follow._91_in_fixed_pointer_declarators7069); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal909_tree = (object)adaptor.Create(char_literal909);
					adaptor.AddChild(root_0, char_literal909_tree);
					}
					DebugLocation(891, 36);
					PushFollow(Follow._fixed_pointer_declarator_in_fixed_pointer_declarators7073);
					fixed_pointer_declarator910=fixed_pointer_declarator();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_pointer_declarator910.Tree);

					}
					break;

				default:
					goto loop241;
				}
			}

			loop241:
				;

			} finally { DebugExitSubRule(241); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("fixed_pointer_declarators", 248);
			LeaveRule("fixed_pointer_declarators", 248);
			Leave_fixed_pointer_declarators();
			if (state.backtracking > 0) { Memoize(input, 248, fixed_pointer_declarators_StartIndex); }
		}
		DebugLocation(891, 62);
		} finally { DebugExitRule(GrammarFileName, "fixed_pointer_declarators"); }
		return retval;

	}
	// $ANTLR end "fixed_pointer_declarators"

	public class fixed_pointer_declarator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_fixed_pointer_declarator();
	partial void Leave_fixed_pointer_declarator();

	// $ANTLR start "fixed_pointer_declarator"
	// cs.g:892:8: public fixed_pointer_declarator : identifier '=' fixed_pointer_initializer ;
	[GrammarRule("fixed_pointer_declarator")]
	public csParser.fixed_pointer_declarator_return fixed_pointer_declarator()
	{
		Enter_fixed_pointer_declarator();
		EnterRule("fixed_pointer_declarator", 249);
		TraceIn("fixed_pointer_declarator", 249);
		csParser.fixed_pointer_declarator_return retval = new csParser.fixed_pointer_declarator_return();
		retval.Start = (IToken)input.LT(1);
		int fixed_pointer_declarator_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal912=null;
		csParser.identifier_return identifier911 = default(csParser.identifier_return);
		csParser.fixed_pointer_initializer_return fixed_pointer_initializer913 = default(csParser.fixed_pointer_initializer_return);

		object char_literal912_tree=null;

		try { DebugEnterRule(GrammarFileName, "fixed_pointer_declarator");
		DebugLocation(892, 46);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 249)) { return retval; }
			// cs.g:892:32: ( identifier '=' fixed_pointer_initializer )
			DebugEnterAlt(1);
			// cs.g:893:2: identifier '=' fixed_pointer_initializer
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(893, 2);
			PushFollow(Follow._identifier_in_fixed_pointer_declarator7085);
			identifier911=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier911.Tree);
			DebugLocation(893, 15);
			char_literal912=(IToken)Match(input,66,Follow._66_in_fixed_pointer_declarator7089); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal912_tree = (object)adaptor.Create(char_literal912);
			adaptor.AddChild(root_0, char_literal912_tree);
			}
			DebugLocation(893, 21);
			PushFollow(Follow._fixed_pointer_initializer_in_fixed_pointer_declarator7093);
			fixed_pointer_initializer913=fixed_pointer_initializer();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_pointer_initializer913.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("fixed_pointer_declarator", 249);
			LeaveRule("fixed_pointer_declarator", 249);
			Leave_fixed_pointer_declarator();
			if (state.backtracking > 0) { Memoize(input, 249, fixed_pointer_declarator_StartIndex); }
		}
		DebugLocation(893, 46);
		} finally { DebugExitRule(GrammarFileName, "fixed_pointer_declarator"); }
		return retval;

	}
	// $ANTLR end "fixed_pointer_declarator"

	public class fixed_pointer_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_fixed_pointer_initializer();
	partial void Leave_fixed_pointer_initializer();

	// $ANTLR start "fixed_pointer_initializer"
	// cs.g:894:8: public fixed_pointer_initializer : expression ;
	[GrammarRule("fixed_pointer_initializer")]
	public csParser.fixed_pointer_initializer_return fixed_pointer_initializer()
	{
		Enter_fixed_pointer_initializer();
		EnterRule("fixed_pointer_initializer", 250);
		TraceIn("fixed_pointer_initializer", 250);
		csParser.fixed_pointer_initializer_return retval = new csParser.fixed_pointer_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int fixed_pointer_initializer_StartIndex = input.Index;
		object root_0 = null;

		csParser.expression_return expression914 = default(csParser.expression_return);


		try { DebugEnterRule(GrammarFileName, "fixed_pointer_initializer");
		DebugLocation(894, 11);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 250)) { return retval; }
			// cs.g:894:33: ( expression )
			DebugEnterAlt(1);
			// cs.g:896:2: expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(896, 2);
			PushFollow(Follow._expression_in_fixed_pointer_initializer7105);
			expression914=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression914.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("fixed_pointer_initializer", 250);
			LeaveRule("fixed_pointer_initializer", 250);
			Leave_fixed_pointer_initializer();
			if (state.backtracking > 0) { Memoize(input, 250, fixed_pointer_initializer_StartIndex); }
		}
		DebugLocation(896, 11);
		} finally { DebugExitRule(GrammarFileName, "fixed_pointer_initializer"); }
		return retval;

	}
	// $ANTLR end "fixed_pointer_initializer"

	public class unsafe_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_unsafe_statement();
	partial void Leave_unsafe_statement();

	// $ANTLR start "unsafe_statement"
	// cs.g:897:8: public unsafe_statement : 'unsafe' block ;
	[GrammarRule("unsafe_statement")]
	public csParser.unsafe_statement_return unsafe_statement()
	{
		Enter_unsafe_statement();
		EnterRule("unsafe_statement", 251);
		TraceIn("unsafe_statement", 251);
		csParser.unsafe_statement_return retval = new csParser.unsafe_statement_return();
		retval.Start = (IToken)input.LT(1);
		int unsafe_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal915=null;
		csParser.block_return block916 = default(csParser.block_return);

		object string_literal915_tree=null;

		try { DebugEnterRule(GrammarFileName, "unsafe_statement");
		DebugLocation(897, 17);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 251)) { return retval; }
			// cs.g:897:24: ( 'unsafe' block )
			DebugEnterAlt(1);
			// cs.g:898:2: 'unsafe' block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(898, 2);
			string_literal915=(IToken)Match(input,73,Follow._73_in_unsafe_statement7114); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal915_tree = (object)adaptor.Create(string_literal915);
			adaptor.AddChild(root_0, string_literal915_tree);
			}
			DebugLocation(898, 13);
			PushFollow(Follow._block_in_unsafe_statement7118);
			block916=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block916.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("unsafe_statement", 251);
			LeaveRule("unsafe_statement", 251);
			Leave_unsafe_statement();
			if (state.backtracking > 0) { Memoize(input, 251, unsafe_statement_StartIndex); }
		}
		DebugLocation(898, 17);
		} finally { DebugExitRule(GrammarFileName, "unsafe_statement"); }
		return retval;

	}
	// $ANTLR end "unsafe_statement"

	public class labeled_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_labeled_statement();
	partial void Leave_labeled_statement();

	// $ANTLR start "labeled_statement"
	// cs.g:899:8: public labeled_statement : identifier ':' statement ;
	[GrammarRule("labeled_statement")]
	public csParser.labeled_statement_return labeled_statement()
	{
		Enter_labeled_statement();
		EnterRule("labeled_statement", 252);
		TraceIn("labeled_statement", 252);
		csParser.labeled_statement_return retval = new csParser.labeled_statement_return();
		retval.Start = (IToken)input.LT(1);
		int labeled_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal918=null;
		csParser.identifier_return identifier917 = default(csParser.identifier_return);
		csParser.statement_return statement919 = default(csParser.statement_return);

		object char_literal918_tree=null;

		try { DebugEnterRule(GrammarFileName, "labeled_statement");
		DebugLocation(899, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 252)) { return retval; }
			// cs.g:899:25: ( identifier ':' statement )
			DebugEnterAlt(1);
			// cs.g:900:2: identifier ':' statement
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(900, 2);
			PushFollow(Follow._identifier_in_labeled_statement7127);
			identifier917=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier917.Tree);
			DebugLocation(900, 15);
			char_literal918=(IToken)Match(input,92,Follow._92_in_labeled_statement7131); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal918_tree = (object)adaptor.Create(char_literal918);
			adaptor.AddChild(root_0, char_literal918_tree);
			}
			DebugLocation(900, 21);
			PushFollow(Follow._statement_in_labeled_statement7135);
			statement919=statement();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement919.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("labeled_statement", 252);
			LeaveRule("labeled_statement", 252);
			Leave_labeled_statement();
			if (state.backtracking > 0) { Memoize(input, 252, labeled_statement_StartIndex); }
		}
		DebugLocation(900, 30);
		} finally { DebugExitRule(GrammarFileName, "labeled_statement"); }
		return retval;

	}
	// $ANTLR end "labeled_statement"

	public class declaration_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_declaration_statement();
	partial void Leave_declaration_statement();

	// $ANTLR start "declaration_statement"
	// cs.g:901:8: public declaration_statement : ( local_variable_declaration | local_constant_declaration ) ';' ;
	[GrammarRule("declaration_statement")]
	public csParser.declaration_statement_return declaration_statement()
	{
		Enter_declaration_statement();
		EnterRule("declaration_statement", 253);
		TraceIn("declaration_statement", 253);
		csParser.declaration_statement_return retval = new csParser.declaration_statement_return();
		retval.Start = (IToken)input.LT(1);
		int declaration_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal922=null;
		csParser.local_variable_declaration_return local_variable_declaration920 = default(csParser.local_variable_declaration_return);
		csParser.local_constant_declaration_return local_constant_declaration921 = default(csParser.local_constant_declaration_return);

		object char_literal922_tree=null;

		try { DebugEnterRule(GrammarFileName, "declaration_statement");
		DebugLocation(901, 35);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 253)) { return retval; }
			// cs.g:901:29: ( ( local_variable_declaration | local_constant_declaration ) ';' )
			DebugEnterAlt(1);
			// cs.g:902:2: ( local_variable_declaration | local_constant_declaration ) ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(902, 2);
			// cs.g:902:2: ( local_variable_declaration | local_constant_declaration )
			int alt242=2;
			try { DebugEnterSubRule(242);
			try { DebugEnterDecision(242, decisionCanBacktrack[242]);
			int LA242_0 = input.LA(1);

			if ((LA242_0==IDENTIFIER||(LA242_0>=ELIF && LA242_0<=UNDEF)||LA242_0==65||LA242_0==82||(LA242_0>=132 && LA242_0<=133)||(LA242_0>=135 && LA242_0<=148)||(LA242_0>=150 && LA242_0<=152)||LA242_0==154||(LA242_0>=156 && LA242_0<=168)||LA242_0==170||(LA242_0>=177 && LA242_0<=178)||(LA242_0>=195 && LA242_0<=202)))
			{
				alt242=1;
			}
			else if ((LA242_0==81))
			{
				alt242=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 242, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(242); }
			switch (alt242)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:902:3: local_variable_declaration
				{
				DebugLocation(902, 3);
				PushFollow(Follow._local_variable_declaration_in_declaration_statement7146);
				local_variable_declaration920=local_variable_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declaration920.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:903:4: local_constant_declaration
				{
				DebugLocation(903, 4);
				PushFollow(Follow._local_constant_declaration_in_declaration_statement7152);
				local_constant_declaration921=local_constant_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_constant_declaration921.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(242); }

			DebugLocation(903, 32);
			char_literal922=(IToken)Match(input,SEMI,Follow._SEMI_in_declaration_statement7155); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal922_tree = (object)adaptor.Create(char_literal922);
			adaptor.AddChild(root_0, char_literal922_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("declaration_statement", 253);
			LeaveRule("declaration_statement", 253);
			Leave_declaration_statement();
			if (state.backtracking > 0) { Memoize(input, 253, declaration_statement_StartIndex); }
		}
		DebugLocation(903, 35);
		} finally { DebugExitRule(GrammarFileName, "declaration_statement"); }
		return retval;

	}
	// $ANTLR end "declaration_statement"

	public class local_variable_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_local_variable_declaration();
	partial void Leave_local_variable_declaration();

	// $ANTLR start "local_variable_declaration"
	// cs.g:904:8: public local_variable_declaration : local_variable_type local_variable_declarators ;
	[GrammarRule("local_variable_declaration")]
	public csParser.local_variable_declaration_return local_variable_declaration()
	{
		Enter_local_variable_declaration();
		EnterRule("local_variable_declaration", 254);
		TraceIn("local_variable_declaration", 254);
		csParser.local_variable_declaration_return retval = new csParser.local_variable_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int local_variable_declaration_StartIndex = input.Index;
		object root_0 = null;

		csParser.local_variable_type_return local_variable_type923 = default(csParser.local_variable_type_return);
		csParser.local_variable_declarators_return local_variable_declarators924 = default(csParser.local_variable_declarators_return);


		try { DebugEnterRule(GrammarFileName, "local_variable_declaration");
		DebugLocation(904, 50);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 254)) { return retval; }
			// cs.g:904:34: ( local_variable_type local_variable_declarators )
			DebugEnterAlt(1);
			// cs.g:905:2: local_variable_type local_variable_declarators
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(905, 2);
			PushFollow(Follow._local_variable_type_in_local_variable_declaration7165);
			local_variable_type923=local_variable_type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_type923.Tree);
			DebugLocation(905, 24);
			PushFollow(Follow._local_variable_declarators_in_local_variable_declaration7169);
			local_variable_declarators924=local_variable_declarators();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declarators924.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("local_variable_declaration", 254);
			LeaveRule("local_variable_declaration", 254);
			Leave_local_variable_declaration();
			if (state.backtracking > 0) { Memoize(input, 254, local_variable_declaration_StartIndex); }
		}
		DebugLocation(905, 50);
		} finally { DebugExitRule(GrammarFileName, "local_variable_declaration"); }
		return retval;

	}
	// $ANTLR end "local_variable_declaration"

	public class local_variable_type_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_local_variable_type();
	partial void Leave_local_variable_type();

	// $ANTLR start "local_variable_type"
	// cs.g:906:8: public local_variable_type : ( ( 'var' )=> 'var' | ( 'dynamic' )=> 'dynamic' | type );
	[GrammarRule("local_variable_type")]
	public csParser.local_variable_type_return local_variable_type()
	{
		Enter_local_variable_type();
		EnterRule("local_variable_type", 255);
		TraceIn("local_variable_type", 255);
		csParser.local_variable_type_return retval = new csParser.local_variable_type_return();
		retval.Start = (IToken)input.LT(1);
		int local_variable_type_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal925=null;
		IToken string_literal926=null;
		csParser.type_return type927 = default(csParser.type_return);

		object string_literal925_tree=null;
		object string_literal926_tree=null;

		try { DebugEnterRule(GrammarFileName, "local_variable_type");
		DebugLocation(906, 8);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 255)) { return retval; }
			// cs.g:906:27: ( ( 'var' )=> 'var' | ( 'dynamic' )=> 'dynamic' | type )
			int alt243=3;
			try { DebugEnterDecision(243, decisionCanBacktrack[243]);
			switch (input.LA(1))
			{
			case 177:
				{
				int LA243_1 = input.LA(2);

				if ((EvaluatePredicate(synpred35_cs_fragment)))
				{
					alt243=1;
				}
				else if ((true))
				{
					alt243=3;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 243, 1, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case 178:
				{
				int LA243_2 = input.LA(2);

				if ((EvaluatePredicate(synpred36_cs_fragment)))
				{
					alt243=2;
				}
				else if ((true))
				{
					alt243=3;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 243, 2, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case IDENTIFIER:
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 82:
			case 132:
			case 133:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 170:
			case 195:
			case 196:
			case 197:
			case 198:
			case 199:
			case 200:
			case 201:
			case 202:
				{
				alt243=3;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 243, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(243); }
			switch (alt243)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:907:2: ( 'var' )=> 'var'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(907, 13);
				string_literal925=(IToken)Match(input,177,Follow._177_in_local_variable_type7185); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal925_tree = (object)adaptor.Create(string_literal925);
				adaptor.AddChild(root_0, string_literal925_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:908:4: ( 'dynamic' )=> 'dynamic'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(908, 19);
				string_literal926=(IToken)Match(input,178,Follow._178_in_local_variable_type7196); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal926_tree = (object)adaptor.Create(string_literal926);
				adaptor.AddChild(root_0, string_literal926_tree);
				}

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:909:4: type
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(909, 4);
				PushFollow(Follow._type_in_local_variable_type7201);
				type927=type();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type927.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("local_variable_type", 255);
			LeaveRule("local_variable_type", 255);
			Leave_local_variable_type();
			if (state.backtracking > 0) { Memoize(input, 255, local_variable_type_StartIndex); }
		}
		DebugLocation(909, 8);
		} finally { DebugExitRule(GrammarFileName, "local_variable_type"); }
		return retval;

	}
	// $ANTLR end "local_variable_type"

	public class local_variable_declarators_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_local_variable_declarators();
	partial void Leave_local_variable_declarators();

	// $ANTLR start "local_variable_declarators"
	// cs.g:910:8: public local_variable_declarators : local_variable_declarator ( ',' local_variable_declarator )* ;
	[GrammarRule("local_variable_declarators")]
	public csParser.local_variable_declarators_return local_variable_declarators()
	{
		Enter_local_variable_declarators();
		EnterRule("local_variable_declarators", 256);
		TraceIn("local_variable_declarators", 256);
		csParser.local_variable_declarators_return retval = new csParser.local_variable_declarators_return();
		retval.Start = (IToken)input.LT(1);
		int local_variable_declarators_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal929=null;
		csParser.local_variable_declarator_return local_variable_declarator928 = default(csParser.local_variable_declarator_return);
		csParser.local_variable_declarator_return local_variable_declarator930 = default(csParser.local_variable_declarator_return);

		object char_literal929_tree=null;

		try { DebugEnterRule(GrammarFileName, "local_variable_declarators");
		DebugLocation(910, 60);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 256)) { return retval; }
			// cs.g:910:34: ( local_variable_declarator ( ',' local_variable_declarator )* )
			DebugEnterAlt(1);
			// cs.g:911:2: local_variable_declarator ( ',' local_variable_declarator )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(911, 2);
			PushFollow(Follow._local_variable_declarator_in_local_variable_declarators7211);
			local_variable_declarator928=local_variable_declarator();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declarator928.Tree);
			DebugLocation(911, 28);
			// cs.g:911:28: ( ',' local_variable_declarator )*
			try { DebugEnterSubRule(244);
			while (true)
			{
				int alt244=2;
				try { DebugEnterDecision(244, decisionCanBacktrack[244]);
				int LA244_0 = input.LA(1);

				if ((LA244_0==91))
				{
					alt244=1;
				}


				} finally { DebugExitDecision(244); }
				switch ( alt244 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:911:29: ',' local_variable_declarator
					{
					DebugLocation(911, 29);
					char_literal929=(IToken)Match(input,91,Follow._91_in_local_variable_declarators7214); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal929_tree = (object)adaptor.Create(char_literal929);
					adaptor.AddChild(root_0, char_literal929_tree);
					}
					DebugLocation(911, 33);
					PushFollow(Follow._local_variable_declarator_in_local_variable_declarators7216);
					local_variable_declarator930=local_variable_declarator();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declarator930.Tree);

					}
					break;

				default:
					goto loop244;
				}
			}

			loop244:
				;

			} finally { DebugExitSubRule(244); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("local_variable_declarators", 256);
			LeaveRule("local_variable_declarators", 256);
			Leave_local_variable_declarators();
			if (state.backtracking > 0) { Memoize(input, 256, local_variable_declarators_StartIndex); }
		}
		DebugLocation(911, 60);
		} finally { DebugExitRule(GrammarFileName, "local_variable_declarators"); }
		return retval;

	}
	// $ANTLR end "local_variable_declarators"

	public class local_variable_declarator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_local_variable_declarator();
	partial void Leave_local_variable_declarator();

	// $ANTLR start "local_variable_declarator"
	// cs.g:912:8: public local_variable_declarator : identifier ( '=' local_variable_initializer )? ;
	[GrammarRule("local_variable_declarator")]
	public csParser.local_variable_declarator_return local_variable_declarator()
	{
		Enter_local_variable_declarator();
		EnterRule("local_variable_declarator", 257);
		TraceIn("local_variable_declarator", 257);
		csParser.local_variable_declarator_return retval = new csParser.local_variable_declarator_return();
		retval.Start = (IToken)input.LT(1);
		int local_variable_declarator_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal932=null;
		csParser.identifier_return identifier931 = default(csParser.identifier_return);
		csParser.local_variable_initializer_return local_variable_initializer933 = default(csParser.local_variable_initializer_return);

		object char_literal932_tree=null;

		try { DebugEnterRule(GrammarFileName, "local_variable_declarator");
		DebugLocation(912, 48);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 257)) { return retval; }
			// cs.g:912:33: ( identifier ( '=' local_variable_initializer )? )
			DebugEnterAlt(1);
			// cs.g:913:2: identifier ( '=' local_variable_initializer )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(913, 2);
			PushFollow(Follow._identifier_in_local_variable_declarator7228);
			identifier931=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier931.Tree);
			DebugLocation(913, 13);
			// cs.g:913:13: ( '=' local_variable_initializer )?
			int alt245=2;
			try { DebugEnterSubRule(245);
			try { DebugEnterDecision(245, decisionCanBacktrack[245]);
			int LA245_0 = input.LA(1);

			if ((LA245_0==66))
			{
				alt245=1;
			}
			} finally { DebugExitDecision(245); }
			switch (alt245)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:913:14: '=' local_variable_initializer
				{
				DebugLocation(913, 14);
				char_literal932=(IToken)Match(input,66,Follow._66_in_local_variable_declarator7231); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal932_tree = (object)adaptor.Create(char_literal932);
				adaptor.AddChild(root_0, char_literal932_tree);
				}
				DebugLocation(913, 20);
				PushFollow(Follow._local_variable_initializer_in_local_variable_declarator7235);
				local_variable_initializer933=local_variable_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_initializer933.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(245); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("local_variable_declarator", 257);
			LeaveRule("local_variable_declarator", 257);
			Leave_local_variable_declarator();
			if (state.backtracking > 0) { Memoize(input, 257, local_variable_declarator_StartIndex); }
		}
		DebugLocation(913, 48);
		} finally { DebugExitRule(GrammarFileName, "local_variable_declarator"); }
		return retval;

	}
	// $ANTLR end "local_variable_declarator"

	public class local_variable_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_local_variable_initializer();
	partial void Leave_local_variable_initializer();

	// $ANTLR start "local_variable_initializer"
	// cs.g:914:8: public local_variable_initializer : ( expression | array_initializer | stackalloc_initializer );
	[GrammarRule("local_variable_initializer")]
	public csParser.local_variable_initializer_return local_variable_initializer()
	{
		Enter_local_variable_initializer();
		EnterRule("local_variable_initializer", 258);
		TraceIn("local_variable_initializer", 258);
		csParser.local_variable_initializer_return retval = new csParser.local_variable_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int local_variable_initializer_StartIndex = input.Index;
		object root_0 = null;

		csParser.expression_return expression934 = default(csParser.expression_return);
		csParser.array_initializer_return array_initializer935 = default(csParser.array_initializer_return);
		csParser.stackalloc_initializer_return stackalloc_initializer936 = default(csParser.stackalloc_initializer_return);


		try { DebugEnterRule(GrammarFileName, "local_variable_initializer");
		DebugLocation(914, 25);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 258)) { return retval; }
			// cs.g:914:34: ( expression | array_initializer | stackalloc_initializer )
			int alt246=3;
			try { DebugEnterDecision(246, decisionCanBacktrack[246]);
			switch (input.LA(1))
			{
			case IDENTIFIER:
			case Real_literal:
			case NUMBER:
			case Hex_number:
			case Character_literal:
			case STRINGLITERAL:
			case Verbatim_string_literal:
			case TRUE:
			case FALSE:
			case NULL:
			case MINUS:
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 68:
			case 83:
			case 84:
			case 86:
			case 87:
			case 90:
			case 95:
			case 96:
			case 97:
			case 98:
			case 99:
			case 100:
			case 102:
			case 104:
			case 105:
			case 106:
			case 117:
			case 132:
			case 133:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 170:
			case 177:
			case 178:
			case 195:
			case 196:
			case 197:
			case 198:
			case 199:
			case 200:
			case 201:
			case 202:
				{
				alt246=1;
				}
				break;
			case 62:
				{
				alt246=2;
				}
				break;
			case 179:
				{
				alt246=3;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 246, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(246); }
			switch (alt246)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:915:2: expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(915, 2);
				PushFollow(Follow._expression_in_local_variable_initializer7248);
				expression934=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression934.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:916:4: array_initializer
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(916, 4);
				PushFollow(Follow._array_initializer_in_local_variable_initializer7253);
				array_initializer935=array_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_initializer935.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:917:4: stackalloc_initializer
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(917, 4);
				PushFollow(Follow._stackalloc_initializer_in_local_variable_initializer7259);
				stackalloc_initializer936=stackalloc_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, stackalloc_initializer936.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("local_variable_initializer", 258);
			LeaveRule("local_variable_initializer", 258);
			Leave_local_variable_initializer();
			if (state.backtracking > 0) { Memoize(input, 258, local_variable_initializer_StartIndex); }
		}
		DebugLocation(917, 25);
		} finally { DebugExitRule(GrammarFileName, "local_variable_initializer"); }
		return retval;

	}
	// $ANTLR end "local_variable_initializer"

	public class stackalloc_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_stackalloc_initializer();
	partial void Leave_stackalloc_initializer();

	// $ANTLR start "stackalloc_initializer"
	// cs.g:918:8: public stackalloc_initializer : 'stackalloc' unmanaged_type '[' expression ']' ;
	[GrammarRule("stackalloc_initializer")]
	public csParser.stackalloc_initializer_return stackalloc_initializer()
	{
		Enter_stackalloc_initializer();
		EnterRule("stackalloc_initializer", 259);
		TraceIn("stackalloc_initializer", 259);
		csParser.stackalloc_initializer_return retval = new csParser.stackalloc_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int stackalloc_initializer_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal937=null;
		IToken char_literal939=null;
		IToken char_literal941=null;
		csParser.unmanaged_type_return unmanaged_type938 = default(csParser.unmanaged_type_return);
		csParser.expression_return expression940 = default(csParser.expression_return);

		object string_literal937_tree=null;
		object char_literal939_tree=null;
		object char_literal941_tree=null;

		try { DebugEnterRule(GrammarFileName, "stackalloc_initializer");
		DebugLocation(918, 56);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 259)) { return retval; }
			// cs.g:918:30: ( 'stackalloc' unmanaged_type '[' expression ']' )
			DebugEnterAlt(1);
			// cs.g:919:2: 'stackalloc' unmanaged_type '[' expression ']'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(919, 2);
			string_literal937=(IToken)Match(input,179,Follow._179_in_stackalloc_initializer7268); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal937_tree = (object)adaptor.Create(string_literal937);
			adaptor.AddChild(root_0, string_literal937_tree);
			}
			DebugLocation(919, 17);
			PushFollow(Follow._unmanaged_type_in_stackalloc_initializer7272);
			unmanaged_type938=unmanaged_type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unmanaged_type938.Tree);
			DebugLocation(919, 34);
			char_literal939=(IToken)Match(input,88,Follow._88_in_stackalloc_initializer7276); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal939_tree = (object)adaptor.Create(char_literal939);
			adaptor.AddChild(root_0, char_literal939_tree);
			}
			DebugLocation(919, 40);
			PushFollow(Follow._expression_in_stackalloc_initializer7280);
			expression940=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression940.Tree);
			DebugLocation(919, 53);
			char_literal941=(IToken)Match(input,89,Follow._89_in_stackalloc_initializer7284); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal941_tree = (object)adaptor.Create(char_literal941);
			adaptor.AddChild(root_0, char_literal941_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("stackalloc_initializer", 259);
			LeaveRule("stackalloc_initializer", 259);
			Leave_stackalloc_initializer();
			if (state.backtracking > 0) { Memoize(input, 259, stackalloc_initializer_StartIndex); }
		}
		DebugLocation(919, 56);
		} finally { DebugExitRule(GrammarFileName, "stackalloc_initializer"); }
		return retval;

	}
	// $ANTLR end "stackalloc_initializer"

	public class local_constant_declaration_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_local_constant_declaration();
	partial void Leave_local_constant_declaration();

	// $ANTLR start "local_constant_declaration"
	// cs.g:920:8: public local_constant_declaration : 'const' type constant_declarators ;
	[GrammarRule("local_constant_declaration")]
	public csParser.local_constant_declaration_return local_constant_declaration()
	{
		Enter_local_constant_declaration();
		EnterRule("local_constant_declaration", 260);
		TraceIn("local_constant_declaration", 260);
		csParser.local_constant_declaration_return retval = new csParser.local_constant_declaration_return();
		retval.Start = (IToken)input.LT(1);
		int local_constant_declaration_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal942=null;
		csParser.type_return type943 = default(csParser.type_return);
		csParser.constant_declarators_return constant_declarators944 = default(csParser.constant_declarators_return);

		object string_literal942_tree=null;

		try { DebugEnterRule(GrammarFileName, "local_constant_declaration");
		DebugLocation(920, 39);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 260)) { return retval; }
			// cs.g:920:34: ( 'const' type constant_declarators )
			DebugEnterAlt(1);
			// cs.g:921:2: 'const' type constant_declarators
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(921, 2);
			string_literal942=(IToken)Match(input,81,Follow._81_in_local_constant_declaration7294); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal942_tree = (object)adaptor.Create(string_literal942);
			adaptor.AddChild(root_0, string_literal942_tree);
			}
			DebugLocation(921, 12);
			PushFollow(Follow._type_in_local_constant_declaration7298);
			type943=type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type943.Tree);
			DebugLocation(921, 19);
			PushFollow(Follow._constant_declarators_in_local_constant_declaration7302);
			constant_declarators944=constant_declarators();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarators944.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("local_constant_declaration", 260);
			LeaveRule("local_constant_declaration", 260);
			Leave_local_constant_declaration();
			if (state.backtracking > 0) { Memoize(input, 260, local_constant_declaration_StartIndex); }
		}
		DebugLocation(921, 39);
		} finally { DebugExitRule(GrammarFileName, "local_constant_declaration"); }
		return retval;

	}
	// $ANTLR end "local_constant_declaration"

	public class expression_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_expression_statement();
	partial void Leave_expression_statement();

	// $ANTLR start "expression_statement"
	// cs.g:922:8: public expression_statement : expression ';' ;
	[GrammarRule("expression_statement")]
	public csParser.expression_statement_return expression_statement()
	{
		Enter_expression_statement();
		EnterRule("expression_statement", 261);
		TraceIn("expression_statement", 261);
		csParser.expression_statement_return retval = new csParser.expression_statement_return();
		retval.Start = (IToken)input.LT(1);
		int expression_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal946=null;
		csParser.expression_return expression945 = default(csParser.expression_return);

		object char_literal946_tree=null;

		try { DebugEnterRule(GrammarFileName, "expression_statement");
		DebugLocation(922, 18);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 261)) { return retval; }
			// cs.g:922:28: ( expression ';' )
			DebugEnterAlt(1);
			// cs.g:923:2: expression ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(923, 2);
			PushFollow(Follow._expression_in_expression_statement7312);
			expression945=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression945.Tree);
			DebugLocation(923, 15);
			char_literal946=(IToken)Match(input,SEMI,Follow._SEMI_in_expression_statement7316); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal946_tree = (object)adaptor.Create(char_literal946);
			adaptor.AddChild(root_0, char_literal946_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("expression_statement", 261);
			LeaveRule("expression_statement", 261);
			Leave_expression_statement();
			if (state.backtracking > 0) { Memoize(input, 261, expression_statement_StartIndex); }
		}
		DebugLocation(923, 18);
		} finally { DebugExitRule(GrammarFileName, "expression_statement"); }
		return retval;

	}
	// $ANTLR end "expression_statement"

	public class statement_expression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_statement_expression();
	partial void Leave_statement_expression();

	// $ANTLR start "statement_expression"
	// cs.g:926:8: public statement_expression : expression ;
	[GrammarRule("statement_expression")]
	public csParser.statement_expression_return statement_expression()
	{
		Enter_statement_expression();
		EnterRule("statement_expression", 262);
		TraceIn("statement_expression", 262);
		csParser.statement_expression_return retval = new csParser.statement_expression_return();
		retval.Start = (IToken)input.LT(1);
		int statement_expression_StartIndex = input.Index;
		object root_0 = null;

		csParser.expression_return expression947 = default(csParser.expression_return);


		try { DebugEnterRule(GrammarFileName, "statement_expression");
		DebugLocation(926, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 262)) { return retval; }
			// cs.g:926:28: ( expression )
			DebugEnterAlt(1);
			// cs.g:927:2: expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(927, 2);
			PushFollow(Follow._expression_in_statement_expression7328);
			expression947=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression947.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("statement_expression", 262);
			LeaveRule("statement_expression", 262);
			Leave_statement_expression();
			if (state.backtracking > 0) { Memoize(input, 262, statement_expression_StartIndex); }
		}
		DebugLocation(928, 1);
		} finally { DebugExitRule(GrammarFileName, "statement_expression"); }
		return retval;

	}
	// $ANTLR end "statement_expression"

	public class selection_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_selection_statement();
	partial void Leave_selection_statement();

	// $ANTLR start "selection_statement"
	// cs.g:929:8: public selection_statement : ( if_statement | switch_statement );
	[GrammarRule("selection_statement")]
	public csParser.selection_statement_return selection_statement()
	{
		Enter_selection_statement();
		EnterRule("selection_statement", 263);
		TraceIn("selection_statement", 263);
		csParser.selection_statement_return retval = new csParser.selection_statement_return();
		retval.Start = (IToken)input.LT(1);
		int selection_statement_StartIndex = input.Index;
		object root_0 = null;

		csParser.if_statement_return if_statement948 = default(csParser.if_statement_return);
		csParser.switch_statement_return switch_statement949 = default(csParser.switch_statement_return);


		try { DebugEnterRule(GrammarFileName, "selection_statement");
		DebugLocation(929, 20);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 263)) { return retval; }
			// cs.g:929:27: ( if_statement | switch_statement )
			int alt247=2;
			try { DebugEnterDecision(247, decisionCanBacktrack[247]);
			int LA247_0 = input.LA(1);

			if ((LA247_0==IF))
			{
				alt247=1;
			}
			else if ((LA247_0==181))
			{
				alt247=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 247, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(247); }
			switch (alt247)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:930:2: if_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(930, 2);
				PushFollow(Follow._if_statement_in_selection_statement7339);
				if_statement948=if_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, if_statement948.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:931:4: switch_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(931, 4);
				PushFollow(Follow._switch_statement_in_selection_statement7344);
				switch_statement949=switch_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_statement949.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("selection_statement", 263);
			LeaveRule("selection_statement", 263);
			Leave_selection_statement();
			if (state.backtracking > 0) { Memoize(input, 263, selection_statement_StartIndex); }
		}
		DebugLocation(931, 20);
		} finally { DebugExitRule(GrammarFileName, "selection_statement"); }
		return retval;

	}
	// $ANTLR end "selection_statement"

	public class if_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_if_statement();
	partial void Leave_if_statement();

	// $ANTLR start "if_statement"
	// cs.g:932:8: public if_statement : 'if' '(' boolean_expression ')' embedded_statement ( ( 'else' )=> else_statement )? ;
	[GrammarRule("if_statement")]
	public csParser.if_statement_return if_statement()
	{
		Enter_if_statement();
		EnterRule("if_statement", 264);
		TraceIn("if_statement", 264);
		csParser.if_statement_return retval = new csParser.if_statement_return();
		retval.Start = (IToken)input.LT(1);
		int if_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal950=null;
		IToken char_literal951=null;
		IToken char_literal953=null;
		csParser.boolean_expression_return boolean_expression952 = default(csParser.boolean_expression_return);
		csParser.embedded_statement_return embedded_statement954 = default(csParser.embedded_statement_return);
		csParser.else_statement_return else_statement955 = default(csParser.else_statement_return);

		object string_literal950_tree=null;
		object char_literal951_tree=null;
		object char_literal953_tree=null;

		try { DebugEnterRule(GrammarFileName, "if_statement");
		DebugLocation(932, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 264)) { return retval; }
			// cs.g:932:20: ( 'if' '(' boolean_expression ')' embedded_statement ( ( 'else' )=> else_statement )? )
			DebugEnterAlt(1);
			// cs.g:934:2: 'if' '(' boolean_expression ')' embedded_statement ( ( 'else' )=> else_statement )?
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(934, 2);
			string_literal950=(IToken)Match(input,IF,Follow._IF_in_if_statement7356); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal950_tree = (object)adaptor.Create(string_literal950);
			adaptor.AddChild(root_0, string_literal950_tree);
			}
			DebugLocation(934, 9);
			char_literal951=(IToken)Match(input,90,Follow._90_in_if_statement7360); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal951_tree = (object)adaptor.Create(char_literal951);
			adaptor.AddChild(root_0, char_literal951_tree);
			}
			DebugLocation(934, 15);
			PushFollow(Follow._boolean_expression_in_if_statement7364);
			boolean_expression952=boolean_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, boolean_expression952.Tree);
			DebugLocation(934, 36);
			char_literal953=(IToken)Match(input,RPAREN,Follow._RPAREN_in_if_statement7368); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal953_tree = (object)adaptor.Create(char_literal953);
			adaptor.AddChild(root_0, char_literal953_tree);
			}
			DebugLocation(934, 42);
			PushFollow(Follow._embedded_statement_in_if_statement7372);
			embedded_statement954=embedded_statement();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement954.Tree);
			DebugLocation(934, 61);
			// cs.g:934:61: ( ( 'else' )=> else_statement )?
			int alt248=2;
			try { DebugEnterSubRule(248);
			try { DebugEnterDecision(248, decisionCanBacktrack[248]);
			int LA248_0 = input.LA(1);

			if ((LA248_0==180))
			{
				int LA248_1 = input.LA(2);

				if ((EvaluatePredicate(synpred37_cs_fragment)))
				{
					alt248=1;
				}
			}
			} finally { DebugExitDecision(248); }
			switch (alt248)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:934:62: ( 'else' )=> else_statement
				{
				DebugLocation(934, 74);
				PushFollow(Follow._else_statement_in_if_statement7381);
				else_statement955=else_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, else_statement955.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(248); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("if_statement", 264);
			LeaveRule("if_statement", 264);
			Leave_if_statement();
			if (state.backtracking > 0) { Memoize(input, 264, if_statement_StartIndex); }
		}
		DebugLocation(935, 1);
		} finally { DebugExitRule(GrammarFileName, "if_statement"); }
		return retval;

	}
	// $ANTLR end "if_statement"

	public class else_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_else_statement();
	partial void Leave_else_statement();

	// $ANTLR start "else_statement"
	// cs.g:936:8: public else_statement : 'else' embedded_statement ;
	[GrammarRule("else_statement")]
	public csParser.else_statement_return else_statement()
	{
		Enter_else_statement();
		EnterRule("else_statement", 265);
		TraceIn("else_statement", 265);
		csParser.else_statement_return retval = new csParser.else_statement_return();
		retval.Start = (IToken)input.LT(1);
		int else_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal956=null;
		csParser.embedded_statement_return embedded_statement957 = default(csParser.embedded_statement_return);

		object string_literal956_tree=null;

		try { DebugEnterRule(GrammarFileName, "else_statement");
		DebugLocation(936, 29);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 265)) { return retval; }
			// cs.g:936:22: ( 'else' embedded_statement )
			DebugEnterAlt(1);
			// cs.g:937:2: 'else' embedded_statement
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(937, 2);
			string_literal956=(IToken)Match(input,180,Follow._180_in_else_statement7394); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal956_tree = (object)adaptor.Create(string_literal956);
			adaptor.AddChild(root_0, string_literal956_tree);
			}
			DebugLocation(937, 11);
			PushFollow(Follow._embedded_statement_in_else_statement7398);
			embedded_statement957=embedded_statement();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement957.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("else_statement", 265);
			LeaveRule("else_statement", 265);
			Leave_else_statement();
			if (state.backtracking > 0) { Memoize(input, 265, else_statement_StartIndex); }
		}
		DebugLocation(937, 29);
		} finally { DebugExitRule(GrammarFileName, "else_statement"); }
		return retval;

	}
	// $ANTLR end "else_statement"

	public class switch_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_switch_statement();
	partial void Leave_switch_statement();

	// $ANTLR start "switch_statement"
	// cs.g:938:8: public switch_statement : 'switch' '(' expression ')' switch_block ;
	[GrammarRule("switch_statement")]
	public csParser.switch_statement_return switch_statement()
	{
		Enter_switch_statement();
		EnterRule("switch_statement", 266);
		TraceIn("switch_statement", 266);
		csParser.switch_statement_return retval = new csParser.switch_statement_return();
		retval.Start = (IToken)input.LT(1);
		int switch_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal958=null;
		IToken char_literal959=null;
		IToken char_literal961=null;
		csParser.expression_return expression960 = default(csParser.expression_return);
		csParser.switch_block_return switch_block962 = default(csParser.switch_block_return);

		object string_literal958_tree=null;
		object char_literal959_tree=null;
		object char_literal961_tree=null;

		try { DebugEnterRule(GrammarFileName, "switch_statement");
		DebugLocation(938, 50);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 266)) { return retval; }
			// cs.g:938:24: ( 'switch' '(' expression ')' switch_block )
			DebugEnterAlt(1);
			// cs.g:939:2: 'switch' '(' expression ')' switch_block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(939, 2);
			string_literal958=(IToken)Match(input,181,Follow._181_in_switch_statement7408); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal958_tree = (object)adaptor.Create(string_literal958);
			adaptor.AddChild(root_0, string_literal958_tree);
			}
			DebugLocation(939, 13);
			char_literal959=(IToken)Match(input,90,Follow._90_in_switch_statement7412); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal959_tree = (object)adaptor.Create(char_literal959);
			adaptor.AddChild(root_0, char_literal959_tree);
			}
			DebugLocation(939, 19);
			PushFollow(Follow._expression_in_switch_statement7416);
			expression960=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression960.Tree);
			DebugLocation(939, 32);
			char_literal961=(IToken)Match(input,RPAREN,Follow._RPAREN_in_switch_statement7420); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal961_tree = (object)adaptor.Create(char_literal961);
			adaptor.AddChild(root_0, char_literal961_tree);
			}
			DebugLocation(939, 38);
			PushFollow(Follow._switch_block_in_switch_statement7424);
			switch_block962=switch_block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_block962.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("switch_statement", 266);
			LeaveRule("switch_statement", 266);
			Leave_switch_statement();
			if (state.backtracking > 0) { Memoize(input, 266, switch_statement_StartIndex); }
		}
		DebugLocation(939, 50);
		} finally { DebugExitRule(GrammarFileName, "switch_statement"); }
		return retval;

	}
	// $ANTLR end "switch_statement"

	public class switch_block_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_switch_block();
	partial void Leave_switch_block();

	// $ANTLR start "switch_block"
	// cs.g:940:8: public switch_block : '{' ( switch_sections )? '}' ;
	[GrammarRule("switch_block")]
	public csParser.switch_block_return switch_block()
	{
		Enter_switch_block();
		EnterRule("switch_block", 267);
		TraceIn("switch_block", 267);
		csParser.switch_block_return retval = new csParser.switch_block_return();
		retval.Start = (IToken)input.LT(1);
		int switch_block_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal963=null;
		IToken char_literal965=null;
		csParser.switch_sections_return switch_sections964 = default(csParser.switch_sections_return);

		object char_literal963_tree=null;
		object char_literal965_tree=null;

		try { DebugEnterRule(GrammarFileName, "switch_block");
		DebugLocation(940, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 267)) { return retval; }
			// cs.g:940:20: ( '{' ( switch_sections )? '}' )
			DebugEnterAlt(1);
			// cs.g:941:2: '{' ( switch_sections )? '}'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(941, 2);
			char_literal963=(IToken)Match(input,62,Follow._62_in_switch_block7434); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal963_tree = (object)adaptor.Create(char_literal963);
			adaptor.AddChild(root_0, char_literal963_tree);
			}
			DebugLocation(941, 8);
			// cs.g:941:8: ( switch_sections )?
			int alt249=2;
			try { DebugEnterSubRule(249);
			try { DebugEnterDecision(249, decisionCanBacktrack[249]);
			int LA249_0 = input.LA(1);

			if ((LA249_0==98||LA249_0==182))
			{
				alt249=1;
			}
			} finally { DebugExitDecision(249); }
			switch (alt249)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:941:8: switch_sections
				{
				DebugLocation(941, 8);
				PushFollow(Follow._switch_sections_in_switch_block7438);
				switch_sections964=switch_sections();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_sections964.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(249); }

			DebugLocation(941, 27);
			char_literal965=(IToken)Match(input,63,Follow._63_in_switch_block7443); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal965_tree = (object)adaptor.Create(char_literal965);
			adaptor.AddChild(root_0, char_literal965_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("switch_block", 267);
			LeaveRule("switch_block", 267);
			Leave_switch_block();
			if (state.backtracking > 0) { Memoize(input, 267, switch_block_StartIndex); }
		}
		DebugLocation(941, 30);
		} finally { DebugExitRule(GrammarFileName, "switch_block"); }
		return retval;

	}
	// $ANTLR end "switch_block"

	public class switch_sections_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_switch_sections();
	partial void Leave_switch_sections();

	// $ANTLR start "switch_sections"
	// cs.g:942:8: public switch_sections : ( switch_section )+ ;
	[GrammarRule("switch_sections")]
	public csParser.switch_sections_return switch_sections()
	{
		Enter_switch_sections();
		EnterRule("switch_sections", 268);
		TraceIn("switch_sections", 268);
		csParser.switch_sections_return retval = new csParser.switch_sections_return();
		retval.Start = (IToken)input.LT(1);
		int switch_sections_StartIndex = input.Index;
		object root_0 = null;

		csParser.switch_section_return switch_section966 = default(csParser.switch_section_return);


		try { DebugEnterRule(GrammarFileName, "switch_sections");
		DebugLocation(942, 17);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 268)) { return retval; }
			// cs.g:942:23: ( ( switch_section )+ )
			DebugEnterAlt(1);
			// cs.g:943:2: ( switch_section )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(943, 2);
			// cs.g:943:2: ( switch_section )+
			int cnt250=0;
			try { DebugEnterSubRule(250);
			while (true)
			{
				int alt250=2;
				try { DebugEnterDecision(250, decisionCanBacktrack[250]);
				int LA250_0 = input.LA(1);

				if ((LA250_0==98||LA250_0==182))
				{
					alt250=1;
				}


				} finally { DebugExitDecision(250); }
				switch (alt250)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:943:2: switch_section
					{
					DebugLocation(943, 2);
					PushFollow(Follow._switch_section_in_switch_sections7453);
					switch_section966=switch_section();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_section966.Tree);

					}
					break;

				default:
					if (cnt250 >= 1)
						goto loop250;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee250 = new EarlyExitException( 250, input );
					DebugRecognitionException(eee250);
					throw eee250;
				}
				cnt250++;
			}
			loop250:
				;

			} finally { DebugExitSubRule(250); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("switch_sections", 268);
			LeaveRule("switch_sections", 268);
			Leave_switch_sections();
			if (state.backtracking > 0) { Memoize(input, 268, switch_sections_StartIndex); }
		}
		DebugLocation(943, 17);
		} finally { DebugExitRule(GrammarFileName, "switch_sections"); }
		return retval;

	}
	// $ANTLR end "switch_sections"

	public class switch_section_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_switch_section();
	partial void Leave_switch_section();

	// $ANTLR start "switch_section"
	// cs.g:944:8: public switch_section : switch_labels statement_list ;
	[GrammarRule("switch_section")]
	public csParser.switch_section_return switch_section()
	{
		Enter_switch_section();
		EnterRule("switch_section", 269);
		TraceIn("switch_section", 269);
		csParser.switch_section_return retval = new csParser.switch_section_return();
		retval.Start = (IToken)input.LT(1);
		int switch_section_StartIndex = input.Index;
		object root_0 = null;

		csParser.switch_labels_return switch_labels967 = default(csParser.switch_labels_return);
		csParser.statement_list_return statement_list968 = default(csParser.statement_list_return);


		try { DebugEnterRule(GrammarFileName, "switch_section");
		DebugLocation(944, 32);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 269)) { return retval; }
			// cs.g:944:22: ( switch_labels statement_list )
			DebugEnterAlt(1);
			// cs.g:945:2: switch_labels statement_list
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(945, 2);
			PushFollow(Follow._switch_labels_in_switch_section7464);
			switch_labels967=switch_labels();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_labels967.Tree);
			DebugLocation(945, 18);
			PushFollow(Follow._statement_list_in_switch_section7468);
			statement_list968=statement_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_list968.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("switch_section", 269);
			LeaveRule("switch_section", 269);
			Leave_switch_section();
			if (state.backtracking > 0) { Memoize(input, 269, switch_section_StartIndex); }
		}
		DebugLocation(945, 32);
		} finally { DebugExitRule(GrammarFileName, "switch_section"); }
		return retval;

	}
	// $ANTLR end "switch_section"

	public class switch_labels_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_switch_labels();
	partial void Leave_switch_labels();

	// $ANTLR start "switch_labels"
	// cs.g:946:8: public switch_labels : ( switch_label )+ ;
	[GrammarRule("switch_labels")]
	public csParser.switch_labels_return switch_labels()
	{
		Enter_switch_labels();
		EnterRule("switch_labels", 270);
		TraceIn("switch_labels", 270);
		csParser.switch_labels_return retval = new csParser.switch_labels_return();
		retval.Start = (IToken)input.LT(1);
		int switch_labels_StartIndex = input.Index;
		object root_0 = null;

		csParser.switch_label_return switch_label969 = default(csParser.switch_label_return);


		try { DebugEnterRule(GrammarFileName, "switch_labels");
		DebugLocation(946, 15);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 270)) { return retval; }
			// cs.g:946:21: ( ( switch_label )+ )
			DebugEnterAlt(1);
			// cs.g:947:2: ( switch_label )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(947, 2);
			// cs.g:947:2: ( switch_label )+
			int cnt251=0;
			try { DebugEnterSubRule(251);
			while (true)
			{
				int alt251=2;
				try { DebugEnterDecision(251, decisionCanBacktrack[251]);
				int LA251_0 = input.LA(1);

				if ((LA251_0==98))
				{
					int LA251_2 = input.LA(2);

					if ((LA251_2==92))
					{
						alt251=1;
					}


				}
				else if ((LA251_0==182))
				{
					alt251=1;
				}


				} finally { DebugExitDecision(251); }
				switch (alt251)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:947:2: switch_label
					{
					DebugLocation(947, 2);
					PushFollow(Follow._switch_label_in_switch_labels7478);
					switch_label969=switch_label();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_label969.Tree);

					}
					break;

				default:
					if (cnt251 >= 1)
						goto loop251;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee251 = new EarlyExitException( 251, input );
					DebugRecognitionException(eee251);
					throw eee251;
				}
				cnt251++;
			}
			loop251:
				;

			} finally { DebugExitSubRule(251); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("switch_labels", 270);
			LeaveRule("switch_labels", 270);
			Leave_switch_labels();
			if (state.backtracking > 0) { Memoize(input, 270, switch_labels_StartIndex); }
		}
		DebugLocation(947, 15);
		} finally { DebugExitRule(GrammarFileName, "switch_labels"); }
		return retval;

	}
	// $ANTLR end "switch_labels"

	public class switch_label_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_switch_label();
	partial void Leave_switch_label();

	// $ANTLR start "switch_label"
	// cs.g:948:8: public switch_label : ( ( 'case' constant_expression ':' ) | ( 'default' ':' ) );
	[GrammarRule("switch_label")]
	public csParser.switch_label_return switch_label()
	{
		Enter_switch_label();
		EnterRule("switch_label", 271);
		TraceIn("switch_label", 271);
		csParser.switch_label_return retval = new csParser.switch_label_return();
		retval.Start = (IToken)input.LT(1);
		int switch_label_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal970=null;
		IToken char_literal972=null;
		IToken string_literal973=null;
		IToken char_literal974=null;
		csParser.constant_expression_return constant_expression971 = default(csParser.constant_expression_return);

		object string_literal970_tree=null;
		object char_literal972_tree=null;
		object string_literal973_tree=null;
		object char_literal974_tree=null;

		try { DebugEnterRule(GrammarFileName, "switch_label");
		DebugLocation(948, 21);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 271)) { return retval; }
			// cs.g:948:20: ( ( 'case' constant_expression ':' ) | ( 'default' ':' ) )
			int alt252=2;
			try { DebugEnterDecision(252, decisionCanBacktrack[252]);
			int LA252_0 = input.LA(1);

			if ((LA252_0==182))
			{
				alt252=1;
			}
			else if ((LA252_0==98))
			{
				alt252=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 252, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(252); }
			switch (alt252)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:949:2: ( 'case' constant_expression ':' )
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(949, 2);
				// cs.g:949:2: ( 'case' constant_expression ':' )
				DebugEnterAlt(1);
				// cs.g:949:3: 'case' constant_expression ':'
				{
				DebugLocation(949, 3);
				string_literal970=(IToken)Match(input,182,Follow._182_in_switch_label7490); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal970_tree = (object)adaptor.Create(string_literal970);
				adaptor.AddChild(root_0, string_literal970_tree);
				}
				DebugLocation(949, 12);
				PushFollow(Follow._constant_expression_in_switch_label7494);
				constant_expression971=constant_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_expression971.Tree);
				DebugLocation(949, 34);
				char_literal972=(IToken)Match(input,92,Follow._92_in_switch_label7498); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal972_tree = (object)adaptor.Create(char_literal972);
				adaptor.AddChild(root_0, char_literal972_tree);
				}

				}


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:950:4: ( 'default' ':' )
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(950, 4);
				// cs.g:950:4: ( 'default' ':' )
				DebugEnterAlt(1);
				// cs.g:950:5: 'default' ':'
				{
				DebugLocation(950, 5);
				string_literal973=(IToken)Match(input,98,Follow._98_in_switch_label7505); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal973_tree = (object)adaptor.Create(string_literal973);
				adaptor.AddChild(root_0, string_literal973_tree);
				}
				DebugLocation(950, 17);
				char_literal974=(IToken)Match(input,92,Follow._92_in_switch_label7509); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal974_tree = (object)adaptor.Create(char_literal974);
				adaptor.AddChild(root_0, char_literal974_tree);
				}

				}


				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("switch_label", 271);
			LeaveRule("switch_label", 271);
			Leave_switch_label();
			if (state.backtracking > 0) { Memoize(input, 271, switch_label_StartIndex); }
		}
		DebugLocation(950, 21);
		} finally { DebugExitRule(GrammarFileName, "switch_label"); }
		return retval;

	}
	// $ANTLR end "switch_label"

	public class iteration_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_iteration_statement();
	partial void Leave_iteration_statement();

	// $ANTLR start "iteration_statement"
	// cs.g:951:8: public iteration_statement : ( while_statement | do_statement | for_statement | foreach_statement );
	[GrammarRule("iteration_statement")]
	public csParser.iteration_statement_return iteration_statement()
	{
		Enter_iteration_statement();
		EnterRule("iteration_statement", 272);
		TraceIn("iteration_statement", 272);
		csParser.iteration_statement_return retval = new csParser.iteration_statement_return();
		retval.Start = (IToken)input.LT(1);
		int iteration_statement_StartIndex = input.Index;
		object root_0 = null;

		csParser.while_statement_return while_statement975 = default(csParser.while_statement_return);
		csParser.do_statement_return do_statement976 = default(csParser.do_statement_return);
		csParser.for_statement_return for_statement977 = default(csParser.for_statement_return);
		csParser.foreach_statement_return foreach_statement978 = default(csParser.foreach_statement_return);


		try { DebugEnterRule(GrammarFileName, "iteration_statement");
		DebugLocation(951, 21);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 272)) { return retval; }
			// cs.g:951:27: ( while_statement | do_statement | for_statement | foreach_statement )
			int alt253=4;
			try { DebugEnterDecision(253, decisionCanBacktrack[253]);
			switch (input.LA(1))
			{
			case 183:
				{
				alt253=1;
				}
				break;
			case 184:
				{
				alt253=2;
				}
				break;
			case 185:
				{
				alt253=3;
				}
				break;
			case 186:
				{
				alt253=4;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 253, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(253); }
			switch (alt253)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:952:2: while_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(952, 2);
				PushFollow(Follow._while_statement_in_iteration_statement7520);
				while_statement975=while_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, while_statement975.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:953:4: do_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(953, 4);
				PushFollow(Follow._do_statement_in_iteration_statement7525);
				do_statement976=do_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, do_statement976.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:954:4: for_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(954, 4);
				PushFollow(Follow._for_statement_in_iteration_statement7530);
				for_statement977=for_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, for_statement977.Tree);

				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:955:4: foreach_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(955, 4);
				PushFollow(Follow._foreach_statement_in_iteration_statement7535);
				foreach_statement978=foreach_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, foreach_statement978.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("iteration_statement", 272);
			LeaveRule("iteration_statement", 272);
			Leave_iteration_statement();
			if (state.backtracking > 0) { Memoize(input, 272, iteration_statement_StartIndex); }
		}
		DebugLocation(955, 21);
		} finally { DebugExitRule(GrammarFileName, "iteration_statement"); }
		return retval;

	}
	// $ANTLR end "iteration_statement"

	public class while_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_while_statement();
	partial void Leave_while_statement();

	// $ANTLR start "while_statement"
	// cs.g:956:8: public while_statement : 'while' '(' boolean_expression ')' embedded_statement ;
	[GrammarRule("while_statement")]
	public csParser.while_statement_return while_statement()
	{
		Enter_while_statement();
		EnterRule("while_statement", 273);
		TraceIn("while_statement", 273);
		csParser.while_statement_return retval = new csParser.while_statement_return();
		retval.Start = (IToken)input.LT(1);
		int while_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal979=null;
		IToken char_literal980=null;
		IToken char_literal982=null;
		csParser.boolean_expression_return boolean_expression981 = default(csParser.boolean_expression_return);
		csParser.embedded_statement_return embedded_statement983 = default(csParser.embedded_statement_return);

		object string_literal979_tree=null;
		object char_literal980_tree=null;
		object char_literal982_tree=null;

		try { DebugEnterRule(GrammarFileName, "while_statement");
		DebugLocation(956, 63);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 273)) { return retval; }
			// cs.g:956:23: ( 'while' '(' boolean_expression ')' embedded_statement )
			DebugEnterAlt(1);
			// cs.g:957:2: 'while' '(' boolean_expression ')' embedded_statement
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(957, 2);
			string_literal979=(IToken)Match(input,183,Follow._183_in_while_statement7545); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal979_tree = (object)adaptor.Create(string_literal979);
			adaptor.AddChild(root_0, string_literal979_tree);
			}
			DebugLocation(957, 12);
			char_literal980=(IToken)Match(input,90,Follow._90_in_while_statement7549); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal980_tree = (object)adaptor.Create(char_literal980);
			adaptor.AddChild(root_0, char_literal980_tree);
			}
			DebugLocation(957, 18);
			PushFollow(Follow._boolean_expression_in_while_statement7553);
			boolean_expression981=boolean_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, boolean_expression981.Tree);
			DebugLocation(957, 39);
			char_literal982=(IToken)Match(input,RPAREN,Follow._RPAREN_in_while_statement7557); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal982_tree = (object)adaptor.Create(char_literal982);
			adaptor.AddChild(root_0, char_literal982_tree);
			}
			DebugLocation(957, 45);
			PushFollow(Follow._embedded_statement_in_while_statement7561);
			embedded_statement983=embedded_statement();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement983.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("while_statement", 273);
			LeaveRule("while_statement", 273);
			Leave_while_statement();
			if (state.backtracking > 0) { Memoize(input, 273, while_statement_StartIndex); }
		}
		DebugLocation(957, 63);
		} finally { DebugExitRule(GrammarFileName, "while_statement"); }
		return retval;

	}
	// $ANTLR end "while_statement"

	public class do_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_do_statement();
	partial void Leave_do_statement();

	// $ANTLR start "do_statement"
	// cs.g:958:8: public do_statement : 'do' embedded_statement 'while' '(' boolean_expression ')' ';' ;
	[GrammarRule("do_statement")]
	public csParser.do_statement_return do_statement()
	{
		Enter_do_statement();
		EnterRule("do_statement", 274);
		TraceIn("do_statement", 274);
		csParser.do_statement_return retval = new csParser.do_statement_return();
		retval.Start = (IToken)input.LT(1);
		int do_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal984=null;
		IToken string_literal986=null;
		IToken char_literal987=null;
		IToken char_literal989=null;
		IToken char_literal990=null;
		csParser.embedded_statement_return embedded_statement985 = default(csParser.embedded_statement_return);
		csParser.boolean_expression_return boolean_expression988 = default(csParser.boolean_expression_return);

		object string_literal984_tree=null;
		object string_literal986_tree=null;
		object char_literal987_tree=null;
		object char_literal989_tree=null;
		object char_literal990_tree=null;

		try { DebugEnterRule(GrammarFileName, "do_statement");
		DebugLocation(958, 76);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 274)) { return retval; }
			// cs.g:958:20: ( 'do' embedded_statement 'while' '(' boolean_expression ')' ';' )
			DebugEnterAlt(1);
			// cs.g:959:2: 'do' embedded_statement 'while' '(' boolean_expression ')' ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(959, 2);
			string_literal984=(IToken)Match(input,184,Follow._184_in_do_statement7571); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal984_tree = (object)adaptor.Create(string_literal984);
			adaptor.AddChild(root_0, string_literal984_tree);
			}
			DebugLocation(959, 9);
			PushFollow(Follow._embedded_statement_in_do_statement7575);
			embedded_statement985=embedded_statement();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement985.Tree);
			DebugLocation(959, 30);
			string_literal986=(IToken)Match(input,183,Follow._183_in_do_statement7579); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal986_tree = (object)adaptor.Create(string_literal986);
			adaptor.AddChild(root_0, string_literal986_tree);
			}
			DebugLocation(959, 40);
			char_literal987=(IToken)Match(input,90,Follow._90_in_do_statement7583); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal987_tree = (object)adaptor.Create(char_literal987);
			adaptor.AddChild(root_0, char_literal987_tree);
			}
			DebugLocation(959, 46);
			PushFollow(Follow._boolean_expression_in_do_statement7587);
			boolean_expression988=boolean_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, boolean_expression988.Tree);
			DebugLocation(959, 67);
			char_literal989=(IToken)Match(input,RPAREN,Follow._RPAREN_in_do_statement7591); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal989_tree = (object)adaptor.Create(char_literal989);
			adaptor.AddChild(root_0, char_literal989_tree);
			}
			DebugLocation(959, 73);
			char_literal990=(IToken)Match(input,SEMI,Follow._SEMI_in_do_statement7595); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal990_tree = (object)adaptor.Create(char_literal990);
			adaptor.AddChild(root_0, char_literal990_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("do_statement", 274);
			LeaveRule("do_statement", 274);
			Leave_do_statement();
			if (state.backtracking > 0) { Memoize(input, 274, do_statement_StartIndex); }
		}
		DebugLocation(959, 76);
		} finally { DebugExitRule(GrammarFileName, "do_statement"); }
		return retval;

	}
	// $ANTLR end "do_statement"

	public class for_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_for_statement();
	partial void Leave_for_statement();

	// $ANTLR start "for_statement"
	// cs.g:960:8: public for_statement : 'for' '(' ( for_initializer )? ';' ( for_condition )? ';' ( for_iterator )? ')' embedded_statement ;
	[GrammarRule("for_statement")]
	public csParser.for_statement_return for_statement()
	{
		Enter_for_statement();
		EnterRule("for_statement", 275);
		TraceIn("for_statement", 275);
		csParser.for_statement_return retval = new csParser.for_statement_return();
		retval.Start = (IToken)input.LT(1);
		int for_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal991=null;
		IToken char_literal992=null;
		IToken char_literal994=null;
		IToken char_literal996=null;
		IToken char_literal998=null;
		csParser.for_initializer_return for_initializer993 = default(csParser.for_initializer_return);
		csParser.for_condition_return for_condition995 = default(csParser.for_condition_return);
		csParser.for_iterator_return for_iterator997 = default(csParser.for_iterator_return);
		csParser.embedded_statement_return embedded_statement999 = default(csParser.embedded_statement_return);

		object string_literal991_tree=null;
		object char_literal992_tree=null;
		object char_literal994_tree=null;
		object char_literal996_tree=null;
		object char_literal998_tree=null;

		try { DebugEnterRule(GrammarFileName, "for_statement");
		DebugLocation(960, 104);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 275)) { return retval; }
			// cs.g:960:21: ( 'for' '(' ( for_initializer )? ';' ( for_condition )? ';' ( for_iterator )? ')' embedded_statement )
			DebugEnterAlt(1);
			// cs.g:961:2: 'for' '(' ( for_initializer )? ';' ( for_condition )? ';' ( for_iterator )? ')' embedded_statement
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(961, 2);
			string_literal991=(IToken)Match(input,185,Follow._185_in_for_statement7605); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal991_tree = (object)adaptor.Create(string_literal991);
			adaptor.AddChild(root_0, string_literal991_tree);
			}
			DebugLocation(961, 10);
			char_literal992=(IToken)Match(input,90,Follow._90_in_for_statement7609); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal992_tree = (object)adaptor.Create(char_literal992);
			adaptor.AddChild(root_0, char_literal992_tree);
			}
			DebugLocation(961, 16);
			// cs.g:961:16: ( for_initializer )?
			int alt254=2;
			try { DebugEnterSubRule(254);
			try { DebugEnterDecision(254, decisionCanBacktrack[254]);
			int LA254_0 = input.LA(1);

			if (((LA254_0>=IDENTIFIER && LA254_0<=NULL)||LA254_0==MINUS||(LA254_0>=ELIF && LA254_0<=UNDEF)||LA254_0==65||LA254_0==68||(LA254_0>=82 && LA254_0<=84)||(LA254_0>=86 && LA254_0<=87)||LA254_0==90||(LA254_0>=95 && LA254_0<=100)||LA254_0==102||(LA254_0>=104 && LA254_0<=106)||LA254_0==117||(LA254_0>=132 && LA254_0<=133)||(LA254_0>=135 && LA254_0<=148)||(LA254_0>=150 && LA254_0<=152)||LA254_0==154||(LA254_0>=156 && LA254_0<=168)||LA254_0==170||(LA254_0>=177 && LA254_0<=178)||(LA254_0>=195 && LA254_0<=202)))
			{
				alt254=1;
			}
			} finally { DebugExitDecision(254); }
			switch (alt254)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:961:16: for_initializer
				{
				DebugLocation(961, 16);
				PushFollow(Follow._for_initializer_in_for_statement7613);
				for_initializer993=for_initializer();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, for_initializer993.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(254); }

			DebugLocation(961, 35);
			char_literal994=(IToken)Match(input,SEMI,Follow._SEMI_in_for_statement7618); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal994_tree = (object)adaptor.Create(char_literal994);
			adaptor.AddChild(root_0, char_literal994_tree);
			}
			DebugLocation(961, 41);
			// cs.g:961:41: ( for_condition )?
			int alt255=2;
			try { DebugEnterSubRule(255);
			try { DebugEnterDecision(255, decisionCanBacktrack[255]);
			int LA255_0 = input.LA(1);

			if (((LA255_0>=IDENTIFIER && LA255_0<=NULL)||LA255_0==MINUS||(LA255_0>=ELIF && LA255_0<=UNDEF)||LA255_0==65||LA255_0==68||(LA255_0>=83 && LA255_0<=84)||(LA255_0>=86 && LA255_0<=87)||LA255_0==90||(LA255_0>=95 && LA255_0<=100)||LA255_0==102||(LA255_0>=104 && LA255_0<=106)||LA255_0==117||(LA255_0>=132 && LA255_0<=133)||(LA255_0>=135 && LA255_0<=148)||(LA255_0>=150 && LA255_0<=152)||LA255_0==154||(LA255_0>=156 && LA255_0<=168)||LA255_0==170||(LA255_0>=177 && LA255_0<=178)||(LA255_0>=195 && LA255_0<=202)))
			{
				alt255=1;
			}
			} finally { DebugExitDecision(255); }
			switch (alt255)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:961:41: for_condition
				{
				DebugLocation(961, 41);
				PushFollow(Follow._for_condition_in_for_statement7622);
				for_condition995=for_condition();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, for_condition995.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(255); }

			DebugLocation(961, 58);
			char_literal996=(IToken)Match(input,SEMI,Follow._SEMI_in_for_statement7627); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal996_tree = (object)adaptor.Create(char_literal996);
			adaptor.AddChild(root_0, char_literal996_tree);
			}
			DebugLocation(961, 64);
			// cs.g:961:64: ( for_iterator )?
			int alt256=2;
			try { DebugEnterSubRule(256);
			try { DebugEnterDecision(256, decisionCanBacktrack[256]);
			int LA256_0 = input.LA(1);

			if (((LA256_0>=IDENTIFIER && LA256_0<=NULL)||LA256_0==MINUS||(LA256_0>=ELIF && LA256_0<=UNDEF)||LA256_0==65||LA256_0==68||(LA256_0>=83 && LA256_0<=84)||(LA256_0>=86 && LA256_0<=87)||LA256_0==90||(LA256_0>=95 && LA256_0<=100)||LA256_0==102||(LA256_0>=104 && LA256_0<=106)||LA256_0==117||(LA256_0>=132 && LA256_0<=133)||(LA256_0>=135 && LA256_0<=148)||(LA256_0>=150 && LA256_0<=152)||LA256_0==154||(LA256_0>=156 && LA256_0<=168)||LA256_0==170||(LA256_0>=177 && LA256_0<=178)||(LA256_0>=195 && LA256_0<=202)))
			{
				alt256=1;
			}
			} finally { DebugExitDecision(256); }
			switch (alt256)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:961:64: for_iterator
				{
				DebugLocation(961, 64);
				PushFollow(Follow._for_iterator_in_for_statement7631);
				for_iterator997=for_iterator();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, for_iterator997.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(256); }

			DebugLocation(961, 80);
			char_literal998=(IToken)Match(input,RPAREN,Follow._RPAREN_in_for_statement7636); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal998_tree = (object)adaptor.Create(char_literal998);
			adaptor.AddChild(root_0, char_literal998_tree);
			}
			DebugLocation(961, 86);
			PushFollow(Follow._embedded_statement_in_for_statement7640);
			embedded_statement999=embedded_statement();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement999.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("for_statement", 275);
			LeaveRule("for_statement", 275);
			Leave_for_statement();
			if (state.backtracking > 0) { Memoize(input, 275, for_statement_StartIndex); }
		}
		DebugLocation(961, 104);
		} finally { DebugExitRule(GrammarFileName, "for_statement"); }
		return retval;

	}
	// $ANTLR end "for_statement"

	public class for_initializer_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_for_initializer();
	partial void Leave_for_initializer();

	// $ANTLR start "for_initializer"
	// cs.g:962:8: public for_initializer : ( ( local_variable_declaration )=> local_variable_declaration | statement_expression_list );
	[GrammarRule("for_initializer")]
	public csParser.for_initializer_return for_initializer()
	{
		Enter_for_initializer();
		EnterRule("for_initializer", 276);
		TraceIn("for_initializer", 276);
		csParser.for_initializer_return retval = new csParser.for_initializer_return();
		retval.Start = (IToken)input.LT(1);
		int for_initializer_StartIndex = input.Index;
		object root_0 = null;

		csParser.local_variable_declaration_return local_variable_declaration1000 = default(csParser.local_variable_declaration_return);
		csParser.statement_expression_list_return statement_expression_list1001 = default(csParser.statement_expression_list_return);


		try { DebugEnterRule(GrammarFileName, "for_initializer");
		DebugLocation(962, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 276)) { return retval; }
			// cs.g:962:23: ( ( local_variable_declaration )=> local_variable_declaration | statement_expression_list )
			int alt257=2;
			try { DebugEnterDecision(257, decisionCanBacktrack[257]);
			try
			{
				alt257 = dfa257.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(257); }
			switch (alt257)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:963:2: ( local_variable_declaration )=> local_variable_declaration
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(963, 34);
				PushFollow(Follow._local_variable_declaration_in_for_initializer7656);
				local_variable_declaration1000=local_variable_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declaration1000.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:964:4: statement_expression_list
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(964, 4);
				PushFollow(Follow._statement_expression_list_in_for_initializer7661);
				statement_expression_list1001=statement_expression_list();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_expression_list1001.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("for_initializer", 276);
			LeaveRule("for_initializer", 276);
			Leave_for_initializer();
			if (state.backtracking > 0) { Memoize(input, 276, for_initializer_StartIndex); }
		}
		DebugLocation(965, 1);
		} finally { DebugExitRule(GrammarFileName, "for_initializer"); }
		return retval;

	}
	// $ANTLR end "for_initializer"

	public class for_condition_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_for_condition();
	partial void Leave_for_condition();

	// $ANTLR start "for_condition"
	// cs.g:966:8: public for_condition : boolean_expression ;
	[GrammarRule("for_condition")]
	public csParser.for_condition_return for_condition()
	{
		Enter_for_condition();
		EnterRule("for_condition", 277);
		TraceIn("for_condition", 277);
		csParser.for_condition_return retval = new csParser.for_condition_return();
		retval.Start = (IToken)input.LT(1);
		int for_condition_StartIndex = input.Index;
		object root_0 = null;

		csParser.boolean_expression_return boolean_expression1002 = default(csParser.boolean_expression_return);


		try { DebugEnterRule(GrammarFileName, "for_condition");
		DebugLocation(966, 20);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 277)) { return retval; }
			// cs.g:966:21: ( boolean_expression )
			DebugEnterAlt(1);
			// cs.g:967:2: boolean_expression
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(967, 2);
			PushFollow(Follow._boolean_expression_in_for_condition7673);
			boolean_expression1002=boolean_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, boolean_expression1002.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("for_condition", 277);
			LeaveRule("for_condition", 277);
			Leave_for_condition();
			if (state.backtracking > 0) { Memoize(input, 277, for_condition_StartIndex); }
		}
		DebugLocation(967, 20);
		} finally { DebugExitRule(GrammarFileName, "for_condition"); }
		return retval;

	}
	// $ANTLR end "for_condition"

	public class for_iterator_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_for_iterator();
	partial void Leave_for_iterator();

	// $ANTLR start "for_iterator"
	// cs.g:968:8: public for_iterator : statement_expression_list ;
	[GrammarRule("for_iterator")]
	public csParser.for_iterator_return for_iterator()
	{
		Enter_for_iterator();
		EnterRule("for_iterator", 278);
		TraceIn("for_iterator", 278);
		csParser.for_iterator_return retval = new csParser.for_iterator_return();
		retval.Start = (IToken)input.LT(1);
		int for_iterator_StartIndex = input.Index;
		object root_0 = null;

		csParser.statement_expression_list_return statement_expression_list1003 = default(csParser.statement_expression_list_return);


		try { DebugEnterRule(GrammarFileName, "for_iterator");
		DebugLocation(968, 27);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 278)) { return retval; }
			// cs.g:968:20: ( statement_expression_list )
			DebugEnterAlt(1);
			// cs.g:969:2: statement_expression_list
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(969, 2);
			PushFollow(Follow._statement_expression_list_in_for_iterator7683);
			statement_expression_list1003=statement_expression_list();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_expression_list1003.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("for_iterator", 278);
			LeaveRule("for_iterator", 278);
			Leave_for_iterator();
			if (state.backtracking > 0) { Memoize(input, 278, for_iterator_StartIndex); }
		}
		DebugLocation(969, 27);
		} finally { DebugExitRule(GrammarFileName, "for_iterator"); }
		return retval;

	}
	// $ANTLR end "for_iterator"

	public class statement_expression_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_statement_expression_list();
	partial void Leave_statement_expression_list();

	// $ANTLR start "statement_expression_list"
	// cs.g:970:8: public statement_expression_list : statement_expression ( ',' statement_expression )* ;
	[GrammarRule("statement_expression_list")]
	public csParser.statement_expression_list_return statement_expression_list()
	{
		Enter_statement_expression_list();
		EnterRule("statement_expression_list", 279);
		TraceIn("statement_expression_list", 279);
		csParser.statement_expression_list_return retval = new csParser.statement_expression_list_return();
		retval.Start = (IToken)input.LT(1);
		int statement_expression_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal1005=null;
		csParser.statement_expression_return statement_expression1004 = default(csParser.statement_expression_return);
		csParser.statement_expression_return statement_expression1006 = default(csParser.statement_expression_return);

		object char_literal1005_tree=null;

		try { DebugEnterRule(GrammarFileName, "statement_expression_list");
		DebugLocation(970, 50);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 279)) { return retval; }
			// cs.g:970:33: ( statement_expression ( ',' statement_expression )* )
			DebugEnterAlt(1);
			// cs.g:971:2: statement_expression ( ',' statement_expression )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(971, 2);
			PushFollow(Follow._statement_expression_in_statement_expression_list7693);
			statement_expression1004=statement_expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_expression1004.Tree);
			DebugLocation(971, 23);
			// cs.g:971:23: ( ',' statement_expression )*
			try { DebugEnterSubRule(258);
			while (true)
			{
				int alt258=2;
				try { DebugEnterDecision(258, decisionCanBacktrack[258]);
				int LA258_0 = input.LA(1);

				if ((LA258_0==91))
				{
					alt258=1;
				}


				} finally { DebugExitDecision(258); }
				switch ( alt258 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:971:24: ',' statement_expression
					{
					DebugLocation(971, 24);
					char_literal1005=(IToken)Match(input,91,Follow._91_in_statement_expression_list7696); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal1005_tree = (object)adaptor.Create(char_literal1005);
					adaptor.AddChild(root_0, char_literal1005_tree);
					}
					DebugLocation(971, 28);
					PushFollow(Follow._statement_expression_in_statement_expression_list7698);
					statement_expression1006=statement_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_expression1006.Tree);

					}
					break;

				default:
					goto loop258;
				}
			}

			loop258:
				;

			} finally { DebugExitSubRule(258); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("statement_expression_list", 279);
			LeaveRule("statement_expression_list", 279);
			Leave_statement_expression_list();
			if (state.backtracking > 0) { Memoize(input, 279, statement_expression_list_StartIndex); }
		}
		DebugLocation(971, 50);
		} finally { DebugExitRule(GrammarFileName, "statement_expression_list"); }
		return retval;

	}
	// $ANTLR end "statement_expression_list"

	public class foreach_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_foreach_statement();
	partial void Leave_foreach_statement();

	// $ANTLR start "foreach_statement"
	// cs.g:972:8: public foreach_statement : 'foreach' '(' local_variable_type identifier 'in' expression ')' embedded_statement ;
	[GrammarRule("foreach_statement")]
	public csParser.foreach_statement_return foreach_statement()
	{
		Enter_foreach_statement();
		EnterRule("foreach_statement", 280);
		TraceIn("foreach_statement", 280);
		csParser.foreach_statement_return retval = new csParser.foreach_statement_return();
		retval.Start = (IToken)input.LT(1);
		int foreach_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1007=null;
		IToken char_literal1008=null;
		IToken string_literal1011=null;
		IToken char_literal1013=null;
		csParser.local_variable_type_return local_variable_type1009 = default(csParser.local_variable_type_return);
		csParser.identifier_return identifier1010 = default(csParser.identifier_return);
		csParser.expression_return expression1012 = default(csParser.expression_return);
		csParser.embedded_statement_return embedded_statement1014 = default(csParser.embedded_statement_return);

		object string_literal1007_tree=null;
		object char_literal1008_tree=null;
		object string_literal1011_tree=null;
		object char_literal1013_tree=null;

		try { DebugEnterRule(GrammarFileName, "foreach_statement");
		DebugLocation(972, 99);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 280)) { return retval; }
			// cs.g:972:25: ( 'foreach' '(' local_variable_type identifier 'in' expression ')' embedded_statement )
			DebugEnterAlt(1);
			// cs.g:973:2: 'foreach' '(' local_variable_type identifier 'in' expression ')' embedded_statement
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(973, 2);
			string_literal1007=(IToken)Match(input,186,Follow._186_in_foreach_statement7710); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1007_tree = (object)adaptor.Create(string_literal1007);
			adaptor.AddChild(root_0, string_literal1007_tree);
			}
			DebugLocation(973, 14);
			char_literal1008=(IToken)Match(input,90,Follow._90_in_foreach_statement7714); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1008_tree = (object)adaptor.Create(char_literal1008);
			adaptor.AddChild(root_0, char_literal1008_tree);
			}
			DebugLocation(973, 20);
			PushFollow(Follow._local_variable_type_in_foreach_statement7718);
			local_variable_type1009=local_variable_type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_type1009.Tree);
			DebugLocation(973, 42);
			PushFollow(Follow._identifier_in_foreach_statement7722);
			identifier1010=identifier();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier1010.Tree);
			DebugLocation(973, 55);
			string_literal1011=(IToken)Match(input,134,Follow._134_in_foreach_statement7726); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1011_tree = (object)adaptor.Create(string_literal1011);
			adaptor.AddChild(root_0, string_literal1011_tree);
			}
			DebugLocation(973, 62);
			PushFollow(Follow._expression_in_foreach_statement7730);
			expression1012=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1012.Tree);
			DebugLocation(973, 75);
			char_literal1013=(IToken)Match(input,RPAREN,Follow._RPAREN_in_foreach_statement7734); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1013_tree = (object)adaptor.Create(char_literal1013);
			adaptor.AddChild(root_0, char_literal1013_tree);
			}
			DebugLocation(973, 81);
			PushFollow(Follow._embedded_statement_in_foreach_statement7738);
			embedded_statement1014=embedded_statement();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement1014.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("foreach_statement", 280);
			LeaveRule("foreach_statement", 280);
			Leave_foreach_statement();
			if (state.backtracking > 0) { Memoize(input, 280, foreach_statement_StartIndex); }
		}
		DebugLocation(973, 99);
		} finally { DebugExitRule(GrammarFileName, "foreach_statement"); }
		return retval;

	}
	// $ANTLR end "foreach_statement"

	public class jump_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_jump_statement();
	partial void Leave_jump_statement();

	// $ANTLR start "jump_statement"
	// cs.g:974:8: public jump_statement : ( break_statement | continue_statement | goto_statement | return_statement | throw_statement );
	[GrammarRule("jump_statement")]
	public csParser.jump_statement_return jump_statement()
	{
		Enter_jump_statement();
		EnterRule("jump_statement", 281);
		TraceIn("jump_statement", 281);
		csParser.jump_statement_return retval = new csParser.jump_statement_return();
		retval.Start = (IToken)input.LT(1);
		int jump_statement_StartIndex = input.Index;
		object root_0 = null;

		csParser.break_statement_return break_statement1015 = default(csParser.break_statement_return);
		csParser.continue_statement_return continue_statement1016 = default(csParser.continue_statement_return);
		csParser.goto_statement_return goto_statement1017 = default(csParser.goto_statement_return);
		csParser.return_statement_return return_statement1018 = default(csParser.return_statement_return);
		csParser.throw_statement_return throw_statement1019 = default(csParser.throw_statement_return);


		try { DebugEnterRule(GrammarFileName, "jump_statement");
		DebugLocation(974, 19);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 281)) { return retval; }
			// cs.g:974:22: ( break_statement | continue_statement | goto_statement | return_statement | throw_statement )
			int alt259=5;
			try { DebugEnterDecision(259, decisionCanBacktrack[259]);
			switch (input.LA(1))
			{
			case 187:
				{
				alt259=1;
				}
				break;
			case 188:
				{
				alt259=2;
				}
				break;
			case 189:
				{
				alt259=3;
				}
				break;
			case 153:
				{
				alt259=4;
				}
				break;
			case 190:
				{
				alt259=5;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 259, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(259); }
			switch (alt259)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:975:2: break_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(975, 2);
				PushFollow(Follow._break_statement_in_jump_statement7748);
				break_statement1015=break_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, break_statement1015.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:976:4: continue_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(976, 4);
				PushFollow(Follow._continue_statement_in_jump_statement7753);
				continue_statement1016=continue_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, continue_statement1016.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:977:4: goto_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(977, 4);
				PushFollow(Follow._goto_statement_in_jump_statement7758);
				goto_statement1017=goto_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, goto_statement1017.Tree);

				}
				break;
			case 4:
				DebugEnterAlt(4);
				// cs.g:978:4: return_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(978, 4);
				PushFollow(Follow._return_statement_in_jump_statement7763);
				return_statement1018=return_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, return_statement1018.Tree);

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// cs.g:979:4: throw_statement
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(979, 4);
				PushFollow(Follow._throw_statement_in_jump_statement7768);
				throw_statement1019=throw_statement();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, throw_statement1019.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("jump_statement", 281);
			LeaveRule("jump_statement", 281);
			Leave_jump_statement();
			if (state.backtracking > 0) { Memoize(input, 281, jump_statement_StartIndex); }
		}
		DebugLocation(979, 19);
		} finally { DebugExitRule(GrammarFileName, "jump_statement"); }
		return retval;

	}
	// $ANTLR end "jump_statement"

	public class break_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_break_statement();
	partial void Leave_break_statement();

	// $ANTLR start "break_statement"
	// cs.g:980:8: public break_statement : 'break' ';' ;
	[GrammarRule("break_statement")]
	public csParser.break_statement_return break_statement()
	{
		Enter_break_statement();
		EnterRule("break_statement", 282);
		TraceIn("break_statement", 282);
		csParser.break_statement_return retval = new csParser.break_statement_return();
		retval.Start = (IToken)input.LT(1);
		int break_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1020=null;
		IToken char_literal1021=null;

		object string_literal1020_tree=null;
		object char_literal1021_tree=null;

		try { DebugEnterRule(GrammarFileName, "break_statement");
		DebugLocation(980, 15);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 282)) { return retval; }
			// cs.g:980:23: ( 'break' ';' )
			DebugEnterAlt(1);
			// cs.g:981:2: 'break' ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(981, 2);
			string_literal1020=(IToken)Match(input,187,Follow._187_in_break_statement7778); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1020_tree = (object)adaptor.Create(string_literal1020);
			adaptor.AddChild(root_0, string_literal1020_tree);
			}
			DebugLocation(981, 12);
			char_literal1021=(IToken)Match(input,SEMI,Follow._SEMI_in_break_statement7782); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1021_tree = (object)adaptor.Create(char_literal1021);
			adaptor.AddChild(root_0, char_literal1021_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("break_statement", 282);
			LeaveRule("break_statement", 282);
			Leave_break_statement();
			if (state.backtracking > 0) { Memoize(input, 282, break_statement_StartIndex); }
		}
		DebugLocation(981, 15);
		} finally { DebugExitRule(GrammarFileName, "break_statement"); }
		return retval;

	}
	// $ANTLR end "break_statement"

	public class continue_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_continue_statement();
	partial void Leave_continue_statement();

	// $ANTLR start "continue_statement"
	// cs.g:982:8: public continue_statement : 'continue' ';' ;
	[GrammarRule("continue_statement")]
	public csParser.continue_statement_return continue_statement()
	{
		Enter_continue_statement();
		EnterRule("continue_statement", 283);
		TraceIn("continue_statement", 283);
		csParser.continue_statement_return retval = new csParser.continue_statement_return();
		retval.Start = (IToken)input.LT(1);
		int continue_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1022=null;
		IToken char_literal1023=null;

		object string_literal1022_tree=null;
		object char_literal1023_tree=null;

		try { DebugEnterRule(GrammarFileName, "continue_statement");
		DebugLocation(982, 18);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 283)) { return retval; }
			// cs.g:982:26: ( 'continue' ';' )
			DebugEnterAlt(1);
			// cs.g:983:2: 'continue' ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(983, 2);
			string_literal1022=(IToken)Match(input,188,Follow._188_in_continue_statement7792); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1022_tree = (object)adaptor.Create(string_literal1022);
			adaptor.AddChild(root_0, string_literal1022_tree);
			}
			DebugLocation(983, 15);
			char_literal1023=(IToken)Match(input,SEMI,Follow._SEMI_in_continue_statement7796); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1023_tree = (object)adaptor.Create(char_literal1023);
			adaptor.AddChild(root_0, char_literal1023_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("continue_statement", 283);
			LeaveRule("continue_statement", 283);
			Leave_continue_statement();
			if (state.backtracking > 0) { Memoize(input, 283, continue_statement_StartIndex); }
		}
		DebugLocation(983, 18);
		} finally { DebugExitRule(GrammarFileName, "continue_statement"); }
		return retval;

	}
	// $ANTLR end "continue_statement"

	public class goto_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_goto_statement();
	partial void Leave_goto_statement();

	// $ANTLR start "goto_statement"
	// cs.g:984:8: public goto_statement : 'goto' ( identifier | 'case' constant_expression | 'default' ) ';' ;
	[GrammarRule("goto_statement")]
	public csParser.goto_statement_return goto_statement()
	{
		Enter_goto_statement();
		EnterRule("goto_statement", 284);
		TraceIn("goto_statement", 284);
		csParser.goto_statement_return retval = new csParser.goto_statement_return();
		retval.Start = (IToken)input.LT(1);
		int goto_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1024=null;
		IToken string_literal1026=null;
		IToken string_literal1028=null;
		IToken char_literal1029=null;
		csParser.identifier_return identifier1025 = default(csParser.identifier_return);
		csParser.constant_expression_return constant_expression1027 = default(csParser.constant_expression_return);

		object string_literal1024_tree=null;
		object string_literal1026_tree=null;
		object string_literal1028_tree=null;
		object char_literal1029_tree=null;

		try { DebugEnterRule(GrammarFileName, "goto_statement");
		DebugLocation(984, 23);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 284)) { return retval; }
			// cs.g:984:22: ( 'goto' ( identifier | 'case' constant_expression | 'default' ) ';' )
			DebugEnterAlt(1);
			// cs.g:985:2: 'goto' ( identifier | 'case' constant_expression | 'default' ) ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(985, 2);
			string_literal1024=(IToken)Match(input,189,Follow._189_in_goto_statement7806); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1024_tree = (object)adaptor.Create(string_literal1024);
			adaptor.AddChild(root_0, string_literal1024_tree);
			}
			DebugLocation(985, 11);
			// cs.g:985:11: ( identifier | 'case' constant_expression | 'default' )
			int alt260=3;
			try { DebugEnterSubRule(260);
			try { DebugEnterDecision(260, decisionCanBacktrack[260]);
			switch (input.LA(1))
			{
			case IDENTIFIER:
			case ELIF:
			case ENDIF:
			case DEFINE:
			case UNDEF:
			case 65:
			case 132:
			case 133:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 150:
			case 151:
			case 152:
			case 154:
			case 156:
			case 157:
			case 158:
			case 159:
			case 170:
			case 177:
			case 178:
			case 195:
			case 202:
				{
				alt260=1;
				}
				break;
			case 182:
				{
				alt260=2;
				}
				break;
			case 98:
				{
				alt260=3;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 260, 0, input);

					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(260); }
			switch (alt260)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:985:13: identifier
				{
				DebugLocation(985, 13);
				PushFollow(Follow._identifier_in_goto_statement7812);
				identifier1025=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier1025.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:986:7: 'case' constant_expression
				{
				DebugLocation(986, 7);
				string_literal1026=(IToken)Match(input,182,Follow._182_in_goto_statement7820); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal1026_tree = (object)adaptor.Create(string_literal1026);
				adaptor.AddChild(root_0, string_literal1026_tree);
				}
				DebugLocation(986, 16);
				PushFollow(Follow._constant_expression_in_goto_statement7824);
				constant_expression1027=constant_expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_expression1027.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// cs.g:987:7: 'default'
				{
				DebugLocation(987, 7);
				string_literal1028=(IToken)Match(input,98,Follow._98_in_goto_statement7832); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal1028_tree = (object)adaptor.Create(string_literal1028);
				adaptor.AddChild(root_0, string_literal1028_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(260); }

			DebugLocation(987, 20);
			char_literal1029=(IToken)Match(input,SEMI,Follow._SEMI_in_goto_statement7837); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1029_tree = (object)adaptor.Create(char_literal1029);
			adaptor.AddChild(root_0, char_literal1029_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("goto_statement", 284);
			LeaveRule("goto_statement", 284);
			Leave_goto_statement();
			if (state.backtracking > 0) { Memoize(input, 284, goto_statement_StartIndex); }
		}
		DebugLocation(987, 23);
		} finally { DebugExitRule(GrammarFileName, "goto_statement"); }
		return retval;

	}
	// $ANTLR end "goto_statement"

	public class return_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_return_statement();
	partial void Leave_return_statement();

	// $ANTLR start "return_statement"
	// cs.g:988:8: public return_statement : 'return' ( expression )? ';' ;
	[GrammarRule("return_statement")]
	public csParser.return_statement_return return_statement()
	{
		Enter_return_statement();
		EnterRule("return_statement", 285);
		TraceIn("return_statement", 285);
		csParser.return_statement_return retval = new csParser.return_statement_return();
		retval.Start = (IToken)input.LT(1);
		int return_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1030=null;
		IToken char_literal1032=null;
		csParser.expression_return expression1031 = default(csParser.expression_return);

		object string_literal1030_tree=null;
		object char_literal1032_tree=null;

		try { DebugEnterRule(GrammarFileName, "return_statement");
		DebugLocation(988, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 285)) { return retval; }
			// cs.g:988:24: ( 'return' ( expression )? ';' )
			DebugEnterAlt(1);
			// cs.g:989:2: 'return' ( expression )? ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(989, 2);
			string_literal1030=(IToken)Match(input,153,Follow._153_in_return_statement7847); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1030_tree = (object)adaptor.Create(string_literal1030);
			adaptor.AddChild(root_0, string_literal1030_tree);
			}
			DebugLocation(989, 13);
			// cs.g:989:13: ( expression )?
			int alt261=2;
			try { DebugEnterSubRule(261);
			try { DebugEnterDecision(261, decisionCanBacktrack[261]);
			int LA261_0 = input.LA(1);

			if (((LA261_0>=IDENTIFIER && LA261_0<=NULL)||LA261_0==MINUS||(LA261_0>=ELIF && LA261_0<=UNDEF)||LA261_0==65||LA261_0==68||(LA261_0>=83 && LA261_0<=84)||(LA261_0>=86 && LA261_0<=87)||LA261_0==90||(LA261_0>=95 && LA261_0<=100)||LA261_0==102||(LA261_0>=104 && LA261_0<=106)||LA261_0==117||(LA261_0>=132 && LA261_0<=133)||(LA261_0>=135 && LA261_0<=148)||(LA261_0>=150 && LA261_0<=152)||LA261_0==154||(LA261_0>=156 && LA261_0<=168)||LA261_0==170||(LA261_0>=177 && LA261_0<=178)||(LA261_0>=195 && LA261_0<=202)))
			{
				alt261=1;
			}
			} finally { DebugExitDecision(261); }
			switch (alt261)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:989:13: expression
				{
				DebugLocation(989, 13);
				PushFollow(Follow._expression_in_return_statement7851);
				expression1031=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1031.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(261); }

			DebugLocation(989, 27);
			char_literal1032=(IToken)Match(input,SEMI,Follow._SEMI_in_return_statement7856); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1032_tree = (object)adaptor.Create(char_literal1032);
			adaptor.AddChild(root_0, char_literal1032_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("return_statement", 285);
			LeaveRule("return_statement", 285);
			Leave_return_statement();
			if (state.backtracking > 0) { Memoize(input, 285, return_statement_StartIndex); }
		}
		DebugLocation(989, 30);
		} finally { DebugExitRule(GrammarFileName, "return_statement"); }
		return retval;

	}
	// $ANTLR end "return_statement"

	public class throw_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_throw_statement();
	partial void Leave_throw_statement();

	// $ANTLR start "throw_statement"
	// cs.g:990:8: public throw_statement : 'throw' ( expression )? ';' ;
	[GrammarRule("throw_statement")]
	public csParser.throw_statement_return throw_statement()
	{
		Enter_throw_statement();
		EnterRule("throw_statement", 286);
		TraceIn("throw_statement", 286);
		csParser.throw_statement_return retval = new csParser.throw_statement_return();
		retval.Start = (IToken)input.LT(1);
		int throw_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1033=null;
		IToken char_literal1035=null;
		csParser.expression_return expression1034 = default(csParser.expression_return);

		object string_literal1033_tree=null;
		object char_literal1035_tree=null;

		try { DebugEnterRule(GrammarFileName, "throw_statement");
		DebugLocation(990, 29);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 286)) { return retval; }
			// cs.g:990:23: ( 'throw' ( expression )? ';' )
			DebugEnterAlt(1);
			// cs.g:991:2: 'throw' ( expression )? ';'
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(991, 2);
			string_literal1033=(IToken)Match(input,190,Follow._190_in_throw_statement7866); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1033_tree = (object)adaptor.Create(string_literal1033);
			adaptor.AddChild(root_0, string_literal1033_tree);
			}
			DebugLocation(991, 12);
			// cs.g:991:12: ( expression )?
			int alt262=2;
			try { DebugEnterSubRule(262);
			try { DebugEnterDecision(262, decisionCanBacktrack[262]);
			int LA262_0 = input.LA(1);

			if (((LA262_0>=IDENTIFIER && LA262_0<=NULL)||LA262_0==MINUS||(LA262_0>=ELIF && LA262_0<=UNDEF)||LA262_0==65||LA262_0==68||(LA262_0>=83 && LA262_0<=84)||(LA262_0>=86 && LA262_0<=87)||LA262_0==90||(LA262_0>=95 && LA262_0<=100)||LA262_0==102||(LA262_0>=104 && LA262_0<=106)||LA262_0==117||(LA262_0>=132 && LA262_0<=133)||(LA262_0>=135 && LA262_0<=148)||(LA262_0>=150 && LA262_0<=152)||LA262_0==154||(LA262_0>=156 && LA262_0<=168)||LA262_0==170||(LA262_0>=177 && LA262_0<=178)||(LA262_0>=195 && LA262_0<=202)))
			{
				alt262=1;
			}
			} finally { DebugExitDecision(262); }
			switch (alt262)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:991:12: expression
				{
				DebugLocation(991, 12);
				PushFollow(Follow._expression_in_throw_statement7870);
				expression1034=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1034.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(262); }

			DebugLocation(991, 26);
			char_literal1035=(IToken)Match(input,SEMI,Follow._SEMI_in_throw_statement7875); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1035_tree = (object)adaptor.Create(char_literal1035);
			adaptor.AddChild(root_0, char_literal1035_tree);
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("throw_statement", 286);
			LeaveRule("throw_statement", 286);
			Leave_throw_statement();
			if (state.backtracking > 0) { Memoize(input, 286, throw_statement_StartIndex); }
		}
		DebugLocation(991, 29);
		} finally { DebugExitRule(GrammarFileName, "throw_statement"); }
		return retval;

	}
	// $ANTLR end "throw_statement"

	public class try_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_try_statement();
	partial void Leave_try_statement();

	// $ANTLR start "try_statement"
	// cs.g:992:8: public try_statement : 'try' block ( catch_clauses ( finally_clause )? | finally_clause ) ;
	[GrammarRule("try_statement")]
	public csParser.try_statement_return try_statement()
	{
		Enter_try_statement();
		EnterRule("try_statement", 287);
		TraceIn("try_statement", 287);
		csParser.try_statement_return retval = new csParser.try_statement_return();
		retval.Start = (IToken)input.LT(1);
		int try_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1036=null;
		csParser.block_return block1037 = default(csParser.block_return);
		csParser.catch_clauses_return catch_clauses1038 = default(csParser.catch_clauses_return);
		csParser.finally_clause_return finally_clause1039 = default(csParser.finally_clause_return);
		csParser.finally_clause_return finally_clause1040 = default(csParser.finally_clause_return);

		object string_literal1036_tree=null;

		try { DebugEnterRule(GrammarFileName, "try_statement");
		DebugLocation(992, 24);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 287)) { return retval; }
			// cs.g:992:21: ( 'try' block ( catch_clauses ( finally_clause )? | finally_clause ) )
			DebugEnterAlt(1);
			// cs.g:993:7: 'try' block ( catch_clauses ( finally_clause )? | finally_clause )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(993, 7);
			string_literal1036=(IToken)Match(input,191,Follow._191_in_try_statement7890); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1036_tree = (object)adaptor.Create(string_literal1036);
			adaptor.AddChild(root_0, string_literal1036_tree);
			}
			DebugLocation(993, 15);
			PushFollow(Follow._block_in_try_statement7894);
			block1037=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1037.Tree);
			DebugLocation(993, 23);
			// cs.g:993:23: ( catch_clauses ( finally_clause )? | finally_clause )
			int alt264=2;
			try { DebugEnterSubRule(264);
			try { DebugEnterDecision(264, decisionCanBacktrack[264]);
			int LA264_0 = input.LA(1);

			if ((LA264_0==192))
			{
				alt264=1;
			}
			else if ((LA264_0==193))
			{
				alt264=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 264, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(264); }
			switch (alt264)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:993:25: catch_clauses ( finally_clause )?
				{
				DebugLocation(993, 25);
				PushFollow(Follow._catch_clauses_in_try_statement7900);
				catch_clauses1038=catch_clauses();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, catch_clauses1038.Tree);
				DebugLocation(993, 41);
				// cs.g:993:41: ( finally_clause )?
				int alt263=2;
				try { DebugEnterSubRule(263);
				try { DebugEnterDecision(263, decisionCanBacktrack[263]);
				int LA263_0 = input.LA(1);

				if ((LA263_0==193))
				{
					alt263=1;
				}
				} finally { DebugExitDecision(263); }
				switch (alt263)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:993:41: finally_clause
					{
					DebugLocation(993, 41);
					PushFollow(Follow._finally_clause_in_try_statement7904);
					finally_clause1039=finally_clause();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, finally_clause1039.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(263); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:994:10: finally_clause
				{
				DebugLocation(994, 10);
				PushFollow(Follow._finally_clause_in_try_statement7916);
				finally_clause1040=finally_clause();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, finally_clause1040.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(264); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("try_statement", 287);
			LeaveRule("try_statement", 287);
			Leave_try_statement();
			if (state.backtracking > 0) { Memoize(input, 287, try_statement_StartIndex); }
		}
		DebugLocation(994, 24);
		} finally { DebugExitRule(GrammarFileName, "try_statement"); }
		return retval;

	}
	// $ANTLR end "try_statement"

	public class catch_clauses_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_catch_clauses();
	partial void Leave_catch_clauses();

	// $ANTLR start "catch_clauses"
	// cs.g:996:8: public catch_clauses : 'catch' ( specific_catch_clauses | general_catch_clause ) ;
	[GrammarRule("catch_clauses")]
	public csParser.catch_clauses_return catch_clauses()
	{
		Enter_catch_clauses();
		EnterRule("catch_clauses", 288);
		TraceIn("catch_clauses", 288);
		csParser.catch_clauses_return retval = new csParser.catch_clauses_return();
		retval.Start = (IToken)input.LT(1);
		int catch_clauses_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1041=null;
		csParser.specific_catch_clauses_return specific_catch_clauses1042 = default(csParser.specific_catch_clauses_return);
		csParser.general_catch_clause_return general_catch_clause1043 = default(csParser.general_catch_clause_return);

		object string_literal1041_tree=null;

		try { DebugEnterRule(GrammarFileName, "catch_clauses");
		DebugLocation(996, 59);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 288)) { return retval; }
			// cs.g:996:21: ( 'catch' ( specific_catch_clauses | general_catch_clause ) )
			DebugEnterAlt(1);
			// cs.g:997:2: 'catch' ( specific_catch_clauses | general_catch_clause )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(997, 2);
			string_literal1041=(IToken)Match(input,192,Follow._192_in_catch_clauses7927); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1041_tree = (object)adaptor.Create(string_literal1041);
			adaptor.AddChild(root_0, string_literal1041_tree);
			}
			DebugLocation(997, 12);
			// cs.g:997:12: ( specific_catch_clauses | general_catch_clause )
			int alt265=2;
			try { DebugEnterSubRule(265);
			try { DebugEnterDecision(265, decisionCanBacktrack[265]);
			int LA265_0 = input.LA(1);

			if ((LA265_0==90))
			{
				alt265=1;
			}
			else if ((LA265_0==SEMI||LA265_0==62))
			{
				alt265=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 265, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(265); }
			switch (alt265)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:997:13: specific_catch_clauses
				{
				DebugLocation(997, 13);
				PushFollow(Follow._specific_catch_clauses_in_catch_clauses7932);
				specific_catch_clauses1042=specific_catch_clauses();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, specific_catch_clauses1042.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:997:38: general_catch_clause
				{
				DebugLocation(997, 38);
				PushFollow(Follow._general_catch_clause_in_catch_clauses7936);
				general_catch_clause1043=general_catch_clause();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, general_catch_clause1043.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(265); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("catch_clauses", 288);
			LeaveRule("catch_clauses", 288);
			Leave_catch_clauses();
			if (state.backtracking > 0) { Memoize(input, 288, catch_clauses_StartIndex); }
		}
		DebugLocation(997, 59);
		} finally { DebugExitRule(GrammarFileName, "catch_clauses"); }
		return retval;

	}
	// $ANTLR end "catch_clauses"

	public class specific_catch_clauses_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_specific_catch_clauses();
	partial void Leave_specific_catch_clauses();

	// $ANTLR start "specific_catch_clauses"
	// cs.g:998:8: public specific_catch_clauses : specific_catch_clause ( 'catch' ( specific_catch_clause | general_catch_clause ) )* ;
	[GrammarRule("specific_catch_clauses")]
	public csParser.specific_catch_clauses_return specific_catch_clauses()
	{
		Enter_specific_catch_clauses();
		EnterRule("specific_catch_clauses", 289);
		TraceIn("specific_catch_clauses", 289);
		csParser.specific_catch_clauses_return retval = new csParser.specific_catch_clauses_return();
		retval.Start = (IToken)input.LT(1);
		int specific_catch_clauses_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1045=null;
		csParser.specific_catch_clause_return specific_catch_clause1044 = default(csParser.specific_catch_clause_return);
		csParser.specific_catch_clause_return specific_catch_clause1046 = default(csParser.specific_catch_clause_return);
		csParser.general_catch_clause_return general_catch_clause1047 = default(csParser.general_catch_clause_return);

		object string_literal1045_tree=null;

		try { DebugEnterRule(GrammarFileName, "specific_catch_clauses");
		DebugLocation(998, 84);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 289)) { return retval; }
			// cs.g:998:30: ( specific_catch_clause ( 'catch' ( specific_catch_clause | general_catch_clause ) )* )
			DebugEnterAlt(1);
			// cs.g:999:2: specific_catch_clause ( 'catch' ( specific_catch_clause | general_catch_clause ) )*
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(999, 2);
			PushFollow(Follow._specific_catch_clause_in_specific_catch_clauses7947);
			specific_catch_clause1044=specific_catch_clause();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, specific_catch_clause1044.Tree);
			DebugLocation(999, 26);
			// cs.g:999:26: ( 'catch' ( specific_catch_clause | general_catch_clause ) )*
			try { DebugEnterSubRule(267);
			while (true)
			{
				int alt267=2;
				try { DebugEnterDecision(267, decisionCanBacktrack[267]);
				int LA267_0 = input.LA(1);

				if ((LA267_0==192))
				{
					alt267=1;
				}


				} finally { DebugExitDecision(267); }
				switch ( alt267 )
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:999:27: 'catch' ( specific_catch_clause | general_catch_clause )
					{
					DebugLocation(999, 27);
					string_literal1045=(IToken)Match(input,192,Follow._192_in_specific_catch_clauses7952); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					string_literal1045_tree = (object)adaptor.Create(string_literal1045);
					adaptor.AddChild(root_0, string_literal1045_tree);
					}
					DebugLocation(999, 37);
					// cs.g:999:37: ( specific_catch_clause | general_catch_clause )
					int alt266=2;
					try { DebugEnterSubRule(266);
					try { DebugEnterDecision(266, decisionCanBacktrack[266]);
					int LA266_0 = input.LA(1);

					if ((LA266_0==90))
					{
						alt266=1;
					}
					else if ((LA266_0==SEMI||LA266_0==62))
					{
						alt266=2;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 266, 0, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
					} finally { DebugExitDecision(266); }
					switch (alt266)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:999:38: specific_catch_clause
						{
						DebugLocation(999, 38);
						PushFollow(Follow._specific_catch_clause_in_specific_catch_clauses7957);
						specific_catch_clause1046=specific_catch_clause();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, specific_catch_clause1046.Tree);

						}
						break;
					case 2:
						DebugEnterAlt(2);
						// cs.g:999:62: general_catch_clause
						{
						DebugLocation(999, 62);
						PushFollow(Follow._general_catch_clause_in_specific_catch_clauses7961);
						general_catch_clause1047=general_catch_clause();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, general_catch_clause1047.Tree);

						}
						break;

					}
					} finally { DebugExitSubRule(266); }


					}
					break;

				default:
					goto loop267;
				}
			}

			loop267:
				;

			} finally { DebugExitSubRule(267); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("specific_catch_clauses", 289);
			LeaveRule("specific_catch_clauses", 289);
			Leave_specific_catch_clauses();
			if (state.backtracking > 0) { Memoize(input, 289, specific_catch_clauses_StartIndex); }
		}
		DebugLocation(999, 84);
		} finally { DebugExitRule(GrammarFileName, "specific_catch_clauses"); }
		return retval;

	}
	// $ANTLR end "specific_catch_clauses"

	public class specific_catch_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_specific_catch_clause();
	partial void Leave_specific_catch_clause();

	// $ANTLR start "specific_catch_clause"
	// cs.g:1000:8: public specific_catch_clause : '(' class_type ( identifier )? ')' block ;
	[GrammarRule("specific_catch_clause")]
	public csParser.specific_catch_clause_return specific_catch_clause()
	{
		Enter_specific_catch_clause();
		EnterRule("specific_catch_clause", 290);
		TraceIn("specific_catch_clause", 290);
		csParser.specific_catch_clause_return retval = new csParser.specific_catch_clause_return();
		retval.Start = (IToken)input.LT(1);
		int specific_catch_clause_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal1048=null;
		IToken char_literal1051=null;
		csParser.class_type_return class_type1049 = default(csParser.class_type_return);
		csParser.identifier_return identifier1050 = default(csParser.identifier_return);
		csParser.block_return block1052 = default(csParser.block_return);

		object char_literal1048_tree=null;
		object char_literal1051_tree=null;

		try { DebugEnterRule(GrammarFileName, "specific_catch_clause");
		DebugLocation(1000, 46);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 290)) { return retval; }
			// cs.g:1000:29: ( '(' class_type ( identifier )? ')' block )
			DebugEnterAlt(1);
			// cs.g:1001:2: '(' class_type ( identifier )? ')' block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1001, 2);
			char_literal1048=(IToken)Match(input,90,Follow._90_in_specific_catch_clause7973); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1048_tree = (object)adaptor.Create(char_literal1048);
			adaptor.AddChild(root_0, char_literal1048_tree);
			}
			DebugLocation(1001, 8);
			PushFollow(Follow._class_type_in_specific_catch_clause7977);
			class_type1049=class_type();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_type1049.Tree);
			DebugLocation(1001, 21);
			// cs.g:1001:21: ( identifier )?
			int alt268=2;
			try { DebugEnterSubRule(268);
			try { DebugEnterDecision(268, decisionCanBacktrack[268]);
			int LA268_0 = input.LA(1);

			if ((LA268_0==IDENTIFIER||(LA268_0>=ELIF && LA268_0<=UNDEF)||LA268_0==65||(LA268_0>=132 && LA268_0<=133)||(LA268_0>=135 && LA268_0<=148)||(LA268_0>=150 && LA268_0<=152)||LA268_0==154||(LA268_0>=156 && LA268_0<=159)||LA268_0==170||(LA268_0>=177 && LA268_0<=178)||LA268_0==195||LA268_0==202))
			{
				alt268=1;
			}
			} finally { DebugExitDecision(268); }
			switch (alt268)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:1001:21: identifier
				{
				DebugLocation(1001, 21);
				PushFollow(Follow._identifier_in_specific_catch_clause7981);
				identifier1050=identifier();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier1050.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(268); }

			DebugLocation(1001, 35);
			char_literal1051=(IToken)Match(input,RPAREN,Follow._RPAREN_in_specific_catch_clause7986); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1051_tree = (object)adaptor.Create(char_literal1051);
			adaptor.AddChild(root_0, char_literal1051_tree);
			}
			DebugLocation(1001, 41);
			PushFollow(Follow._block_in_specific_catch_clause7990);
			block1052=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1052.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("specific_catch_clause", 290);
			LeaveRule("specific_catch_clause", 290);
			Leave_specific_catch_clause();
			if (state.backtracking > 0) { Memoize(input, 290, specific_catch_clause_StartIndex); }
		}
		DebugLocation(1001, 46);
		} finally { DebugExitRule(GrammarFileName, "specific_catch_clause"); }
		return retval;

	}
	// $ANTLR end "specific_catch_clause"

	public class general_catch_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_general_catch_clause();
	partial void Leave_general_catch_clause();

	// $ANTLR start "general_catch_clause"
	// cs.g:1002:8: public general_catch_clause : block ;
	[GrammarRule("general_catch_clause")]
	public csParser.general_catch_clause_return general_catch_clause()
	{
		Enter_general_catch_clause();
		EnterRule("general_catch_clause", 291);
		TraceIn("general_catch_clause", 291);
		csParser.general_catch_clause_return retval = new csParser.general_catch_clause_return();
		retval.Start = (IToken)input.LT(1);
		int general_catch_clause_StartIndex = input.Index;
		object root_0 = null;

		csParser.block_return block1053 = default(csParser.block_return);


		try { DebugEnterRule(GrammarFileName, "general_catch_clause");
		DebugLocation(1002, 7);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 291)) { return retval; }
			// cs.g:1002:28: ( block )
			DebugEnterAlt(1);
			// cs.g:1003:2: block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1003, 2);
			PushFollow(Follow._block_in_general_catch_clause8000);
			block1053=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1053.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("general_catch_clause", 291);
			LeaveRule("general_catch_clause", 291);
			Leave_general_catch_clause();
			if (state.backtracking > 0) { Memoize(input, 291, general_catch_clause_StartIndex); }
		}
		DebugLocation(1003, 7);
		} finally { DebugExitRule(GrammarFileName, "general_catch_clause"); }
		return retval;

	}
	// $ANTLR end "general_catch_clause"

	public class finally_clause_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_finally_clause();
	partial void Leave_finally_clause();

	// $ANTLR start "finally_clause"
	// cs.g:1004:8: public finally_clause : 'finally' block ;
	[GrammarRule("finally_clause")]
	public csParser.finally_clause_return finally_clause()
	{
		Enter_finally_clause();
		EnterRule("finally_clause", 292);
		TraceIn("finally_clause", 292);
		csParser.finally_clause_return retval = new csParser.finally_clause_return();
		retval.Start = (IToken)input.LT(1);
		int finally_clause_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1054=null;
		csParser.block_return block1055 = default(csParser.block_return);

		object string_literal1054_tree=null;

		try { DebugEnterRule(GrammarFileName, "finally_clause");
		DebugLocation(1004, 19);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 292)) { return retval; }
			// cs.g:1004:22: ( 'finally' block )
			DebugEnterAlt(1);
			// cs.g:1005:2: 'finally' block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1005, 2);
			string_literal1054=(IToken)Match(input,193,Follow._193_in_finally_clause8010); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1054_tree = (object)adaptor.Create(string_literal1054);
			adaptor.AddChild(root_0, string_literal1054_tree);
			}
			DebugLocation(1005, 14);
			PushFollow(Follow._block_in_finally_clause8014);
			block1055=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1055.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("finally_clause", 292);
			LeaveRule("finally_clause", 292);
			Leave_finally_clause();
			if (state.backtracking > 0) { Memoize(input, 292, finally_clause_StartIndex); }
		}
		DebugLocation(1005, 19);
		} finally { DebugExitRule(GrammarFileName, "finally_clause"); }
		return retval;

	}
	// $ANTLR end "finally_clause"

	public class checked_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_checked_statement();
	partial void Leave_checked_statement();

	// $ANTLR start "checked_statement"
	// cs.g:1006:8: public checked_statement : 'checked' block ;
	[GrammarRule("checked_statement")]
	public csParser.checked_statement_return checked_statement()
	{
		Enter_checked_statement();
		EnterRule("checked_statement", 293);
		TraceIn("checked_statement", 293);
		csParser.checked_statement_return retval = new csParser.checked_statement_return();
		retval.Start = (IToken)input.LT(1);
		int checked_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1056=null;
		csParser.block_return block1057 = default(csParser.block_return);

		object string_literal1056_tree=null;

		try { DebugEnterRule(GrammarFileName, "checked_statement");
		DebugLocation(1006, 19);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 293)) { return retval; }
			// cs.g:1006:25: ( 'checked' block )
			DebugEnterAlt(1);
			// cs.g:1007:2: 'checked' block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1007, 2);
			string_literal1056=(IToken)Match(input,96,Follow._96_in_checked_statement8024); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1056_tree = (object)adaptor.Create(string_literal1056);
			adaptor.AddChild(root_0, string_literal1056_tree);
			}
			DebugLocation(1007, 14);
			PushFollow(Follow._block_in_checked_statement8028);
			block1057=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1057.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("checked_statement", 293);
			LeaveRule("checked_statement", 293);
			Leave_checked_statement();
			if (state.backtracking > 0) { Memoize(input, 293, checked_statement_StartIndex); }
		}
		DebugLocation(1007, 19);
		} finally { DebugExitRule(GrammarFileName, "checked_statement"); }
		return retval;

	}
	// $ANTLR end "checked_statement"

	public class unchecked_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_unchecked_statement();
	partial void Leave_unchecked_statement();

	// $ANTLR start "unchecked_statement"
	// cs.g:1008:8: public unchecked_statement : 'unchecked' block ;
	[GrammarRule("unchecked_statement")]
	public csParser.unchecked_statement_return unchecked_statement()
	{
		Enter_unchecked_statement();
		EnterRule("unchecked_statement", 294);
		TraceIn("unchecked_statement", 294);
		csParser.unchecked_statement_return retval = new csParser.unchecked_statement_return();
		retval.Start = (IToken)input.LT(1);
		int unchecked_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1058=null;
		csParser.block_return block1059 = default(csParser.block_return);

		object string_literal1058_tree=null;

		try { DebugEnterRule(GrammarFileName, "unchecked_statement");
		DebugLocation(1008, 21);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 294)) { return retval; }
			// cs.g:1008:27: ( 'unchecked' block )
			DebugEnterAlt(1);
			// cs.g:1009:2: 'unchecked' block
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1009, 2);
			string_literal1058=(IToken)Match(input,97,Follow._97_in_unchecked_statement8038); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1058_tree = (object)adaptor.Create(string_literal1058);
			adaptor.AddChild(root_0, string_literal1058_tree);
			}
			DebugLocation(1009, 16);
			PushFollow(Follow._block_in_unchecked_statement8042);
			block1059=block();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1059.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("unchecked_statement", 294);
			LeaveRule("unchecked_statement", 294);
			Leave_unchecked_statement();
			if (state.backtracking > 0) { Memoize(input, 294, unchecked_statement_StartIndex); }
		}
		DebugLocation(1009, 21);
		} finally { DebugExitRule(GrammarFileName, "unchecked_statement"); }
		return retval;

	}
	// $ANTLR end "unchecked_statement"

	public class lock_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_lock_statement();
	partial void Leave_lock_statement();

	// $ANTLR start "lock_statement"
	// cs.g:1010:8: public lock_statement : 'lock' '(' expression ')' embedded_statement ;
	[GrammarRule("lock_statement")]
	public csParser.lock_statement_return lock_statement()
	{
		Enter_lock_statement();
		EnterRule("lock_statement", 295);
		TraceIn("lock_statement", 295);
		csParser.lock_statement_return retval = new csParser.lock_statement_return();
		retval.Start = (IToken)input.LT(1);
		int lock_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1060=null;
		IToken char_literal1061=null;
		IToken char_literal1063=null;
		csParser.expression_return expression1062 = default(csParser.expression_return);
		csParser.embedded_statement_return embedded_statement1064 = default(csParser.embedded_statement_return);

		object string_literal1060_tree=null;
		object char_literal1061_tree=null;
		object char_literal1063_tree=null;

		try { DebugEnterRule(GrammarFileName, "lock_statement");
		DebugLocation(1010, 53);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 295)) { return retval; }
			// cs.g:1010:22: ( 'lock' '(' expression ')' embedded_statement )
			DebugEnterAlt(1);
			// cs.g:1011:2: 'lock' '(' expression ')' embedded_statement
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1011, 2);
			string_literal1060=(IToken)Match(input,194,Follow._194_in_lock_statement8052); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1060_tree = (object)adaptor.Create(string_literal1060);
			adaptor.AddChild(root_0, string_literal1060_tree);
			}
			DebugLocation(1011, 11);
			char_literal1061=(IToken)Match(input,90,Follow._90_in_lock_statement8056); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1061_tree = (object)adaptor.Create(char_literal1061);
			adaptor.AddChild(root_0, char_literal1061_tree);
			}
			DebugLocation(1011, 16);
			PushFollow(Follow._expression_in_lock_statement8059);
			expression1062=expression();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1062.Tree);
			DebugLocation(1011, 29);
			char_literal1063=(IToken)Match(input,RPAREN,Follow._RPAREN_in_lock_statement8063); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1063_tree = (object)adaptor.Create(char_literal1063);
			adaptor.AddChild(root_0, char_literal1063_tree);
			}
			DebugLocation(1011, 35);
			PushFollow(Follow._embedded_statement_in_lock_statement8067);
			embedded_statement1064=embedded_statement();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement1064.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("lock_statement", 295);
			LeaveRule("lock_statement", 295);
			Leave_lock_statement();
			if (state.backtracking > 0) { Memoize(input, 295, lock_statement_StartIndex); }
		}
		DebugLocation(1011, 53);
		} finally { DebugExitRule(GrammarFileName, "lock_statement"); }
		return retval;

	}
	// $ANTLR end "lock_statement"

	public class using_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_using_statement();
	partial void Leave_using_statement();

	// $ANTLR start "using_statement"
	// cs.g:1012:8: public using_statement : 'using' '(' resource_acquisition ')' embedded_statement ;
	[GrammarRule("using_statement")]
	public csParser.using_statement_return using_statement()
	{
		Enter_using_statement();
		EnterRule("using_statement", 296);
		TraceIn("using_statement", 296);
		csParser.using_statement_return retval = new csParser.using_statement_return();
		retval.Start = (IToken)input.LT(1);
		int using_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1065=null;
		IToken char_literal1066=null;
		IToken char_literal1068=null;
		csParser.resource_acquisition_return resource_acquisition1067 = default(csParser.resource_acquisition_return);
		csParser.embedded_statement_return embedded_statement1069 = default(csParser.embedded_statement_return);

		object string_literal1065_tree=null;
		object char_literal1066_tree=null;
		object char_literal1068_tree=null;

		try { DebugEnterRule(GrammarFileName, "using_statement");
		DebugLocation(1012, 67);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 296)) { return retval; }
			// cs.g:1012:23: ( 'using' '(' resource_acquisition ')' embedded_statement )
			DebugEnterAlt(1);
			// cs.g:1013:2: 'using' '(' resource_acquisition ')' embedded_statement
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1013, 2);
			string_literal1065=(IToken)Match(input,USING,Follow._USING_in_using_statement8077); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1065_tree = (object)adaptor.Create(string_literal1065);
			adaptor.AddChild(root_0, string_literal1065_tree);
			}
			DebugLocation(1013, 12);
			char_literal1066=(IToken)Match(input,90,Follow._90_in_using_statement8081); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1066_tree = (object)adaptor.Create(char_literal1066);
			adaptor.AddChild(root_0, char_literal1066_tree);
			}
			DebugLocation(1013, 19);
			PushFollow(Follow._resource_acquisition_in_using_statement8086);
			resource_acquisition1067=resource_acquisition();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, resource_acquisition1067.Tree);
			DebugLocation(1013, 42);
			char_literal1068=(IToken)Match(input,RPAREN,Follow._RPAREN_in_using_statement8090); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal1068_tree = (object)adaptor.Create(char_literal1068);
			adaptor.AddChild(root_0, char_literal1068_tree);
			}
			DebugLocation(1013, 49);
			PushFollow(Follow._embedded_statement_in_using_statement8095);
			embedded_statement1069=embedded_statement();
			PopFollow();
			if (state.failed) return retval;
			if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement1069.Tree);

			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("using_statement", 296);
			LeaveRule("using_statement", 296);
			Leave_using_statement();
			if (state.backtracking > 0) { Memoize(input, 296, using_statement_StartIndex); }
		}
		DebugLocation(1013, 67);
		} finally { DebugExitRule(GrammarFileName, "using_statement"); }
		return retval;

	}
	// $ANTLR end "using_statement"

	public class resource_acquisition_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_resource_acquisition();
	partial void Leave_resource_acquisition();

	// $ANTLR start "resource_acquisition"
	// cs.g:1014:8: public resource_acquisition : ( ( local_variable_declaration )=> local_variable_declaration | expression );
	[GrammarRule("resource_acquisition")]
	public csParser.resource_acquisition_return resource_acquisition()
	{
		Enter_resource_acquisition();
		EnterRule("resource_acquisition", 297);
		TraceIn("resource_acquisition", 297);
		csParser.resource_acquisition_return retval = new csParser.resource_acquisition_return();
		retval.Start = (IToken)input.LT(1);
		int resource_acquisition_StartIndex = input.Index;
		object root_0 = null;

		csParser.local_variable_declaration_return local_variable_declaration1070 = default(csParser.local_variable_declaration_return);
		csParser.expression_return expression1071 = default(csParser.expression_return);


		try { DebugEnterRule(GrammarFileName, "resource_acquisition");
		DebugLocation(1014, 14);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 297)) { return retval; }
			// cs.g:1014:28: ( ( local_variable_declaration )=> local_variable_declaration | expression )
			int alt269=2;
			try { DebugEnterDecision(269, decisionCanBacktrack[269]);
			try
			{
				alt269 = dfa269.Predict(input);
			}
			catch (NoViableAltException nvae)
			{
				DebugRecognitionException(nvae);
				throw;
			}
			} finally { DebugExitDecision(269); }
			switch (alt269)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:1015:2: ( local_variable_declaration )=> local_variable_declaration
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(1015, 34);
				PushFollow(Follow._local_variable_declaration_in_resource_acquisition8111);
				local_variable_declaration1070=local_variable_declaration();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declaration1070.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:1016:4: expression
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(1016, 4);
				PushFollow(Follow._expression_in_resource_acquisition8116);
				expression1071=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1071.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("resource_acquisition", 297);
			LeaveRule("resource_acquisition", 297);
			Leave_resource_acquisition();
			if (state.backtracking > 0) { Memoize(input, 297, resource_acquisition_StartIndex); }
		}
		DebugLocation(1016, 14);
		} finally { DebugExitRule(GrammarFileName, "resource_acquisition"); }
		return retval;

	}
	// $ANTLR end "resource_acquisition"

	public class yield_statement_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_yield_statement();
	partial void Leave_yield_statement();

	// $ANTLR start "yield_statement"
	// cs.g:1017:8: public yield_statement : 'yield' ( 'return' expression ';' | 'break' ';' ) ;
	[GrammarRule("yield_statement")]
	public csParser.yield_statement_return yield_statement()
	{
		Enter_yield_statement();
		EnterRule("yield_statement", 298);
		TraceIn("yield_statement", 298);
		csParser.yield_statement_return retval = new csParser.yield_statement_return();
		retval.Start = (IToken)input.LT(1);
		int yield_statement_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1072=null;
		IToken string_literal1073=null;
		IToken char_literal1075=null;
		IToken string_literal1076=null;
		IToken char_literal1077=null;
		csParser.expression_return expression1074 = default(csParser.expression_return);

		object string_literal1072_tree=null;
		object string_literal1073_tree=null;
		object char_literal1075_tree=null;
		object string_literal1076_tree=null;
		object char_literal1077_tree=null;

		try { DebugEnterRule(GrammarFileName, "yield_statement");
		DebugLocation(1017, 28);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 298)) { return retval; }
			// cs.g:1017:23: ( 'yield' ( 'return' expression ';' | 'break' ';' ) )
			DebugEnterAlt(1);
			// cs.g:1018:2: 'yield' ( 'return' expression ';' | 'break' ';' )
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1018, 2);
			string_literal1072=(IToken)Match(input,195,Follow._195_in_yield_statement8126); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			string_literal1072_tree = (object)adaptor.Create(string_literal1072);
			adaptor.AddChild(root_0, string_literal1072_tree);
			}
			DebugLocation(1018, 12);
			// cs.g:1018:12: ( 'return' expression ';' | 'break' ';' )
			int alt270=2;
			try { DebugEnterSubRule(270);
			try { DebugEnterDecision(270, decisionCanBacktrack[270]);
			int LA270_0 = input.LA(1);

			if ((LA270_0==153))
			{
				alt270=1;
			}
			else if ((LA270_0==187))
			{
				alt270=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 270, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(270); }
			switch (alt270)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:1018:13: 'return' expression ';'
				{
				DebugLocation(1018, 13);
				string_literal1073=(IToken)Match(input,153,Follow._153_in_yield_statement8131); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal1073_tree = (object)adaptor.Create(string_literal1073);
				adaptor.AddChild(root_0, string_literal1073_tree);
				}
				DebugLocation(1018, 24);
				PushFollow(Follow._expression_in_yield_statement8135);
				expression1074=expression();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1074.Tree);
				DebugLocation(1018, 37);
				char_literal1075=(IToken)Match(input,SEMI,Follow._SEMI_in_yield_statement8139); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal1075_tree = (object)adaptor.Create(char_literal1075);
				adaptor.AddChild(root_0, char_literal1075_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:1019:14: 'break' ';'
				{
				DebugLocation(1019, 14);
				string_literal1076=(IToken)Match(input,187,Follow._187_in_yield_statement8154); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				string_literal1076_tree = (object)adaptor.Create(string_literal1076);
				adaptor.AddChild(root_0, string_literal1076_tree);
				}
				DebugLocation(1019, 24);
				char_literal1077=(IToken)Match(input,SEMI,Follow._SEMI_in_yield_statement8158); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				char_literal1077_tree = (object)adaptor.Create(char_literal1077);
				adaptor.AddChild(root_0, char_literal1077_tree);
				}

				}
				break;

			}
			} finally { DebugExitSubRule(270); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("yield_statement", 298);
			LeaveRule("yield_statement", 298);
			Leave_yield_statement();
			if (state.backtracking > 0) { Memoize(input, 298, yield_statement_StartIndex); }
		}
		DebugLocation(1019, 28);
		} finally { DebugExitRule(GrammarFileName, "yield_statement"); }
		return retval;

	}
	// $ANTLR end "yield_statement"

	public class predefined_type_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_predefined_type();
	partial void Leave_predefined_type();

	// $ANTLR start "predefined_type"
	// cs.g:1025:8: public predefined_type : ( 'bool' | 'byte' | 'char' | 'decimal' | 'double' | 'float' | 'int' | 'long' | 'object' | 'sbyte' | 'short' | 'string' | 'uint' | 'ulong' | 'ushort' );
	[GrammarRule("predefined_type")]
	public csParser.predefined_type_return predefined_type()
	{
		Enter_predefined_type();
		EnterRule("predefined_type", 299);
		TraceIn("predefined_type", 299);
		csParser.predefined_type_return retval = new csParser.predefined_type_return();
		retval.Start = (IToken)input.LT(1);
		int predefined_type_StartIndex = input.Index;
		object root_0 = null;

		IToken set1078=null;

		object set1078_tree=null;

		try { DebugEnterRule(GrammarFileName, "predefined_type");
		DebugLocation(1025, 56);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 299)) { return retval; }
			// cs.g:1025:23: ( 'bool' | 'byte' | 'char' | 'decimal' | 'double' | 'float' | 'int' | 'long' | 'object' | 'sbyte' | 'short' | 'string' | 'uint' | 'ulong' | 'ushort' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1025, 23);
			set1078=(IToken)input.LT(1);
			if ((input.LA(1)>=160 && input.LA(1)<=168)||(input.LA(1)>=196 && input.LA(1)<=201))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set1078));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("predefined_type", 299);
			LeaveRule("predefined_type", 299);
			Leave_predefined_type();
			if (state.backtracking > 0) { Memoize(input, 299, predefined_type_StartIndex); }
		}
		DebugLocation(1027, 56);
		} finally { DebugExitRule(GrammarFileName, "predefined_type"); }
		return retval;

	}
	// $ANTLR end "predefined_type"

	public class identifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_identifier();
	partial void Leave_identifier();

	// $ANTLR start "identifier"
	// cs.g:1029:8: public identifier : ( IDENTIFIER | also_keyword );
	[GrammarRule("identifier")]
	public csParser.identifier_return identifier()
	{
		Enter_identifier();
		EnterRule("identifier", 300);
		TraceIn("identifier", 300);
		csParser.identifier_return retval = new csParser.identifier_return();
		retval.Start = (IToken)input.LT(1);
		int identifier_StartIndex = input.Index;
		object root_0 = null;

		IToken IDENTIFIER1079=null;
		csParser.also_keyword_return also_keyword1080 = default(csParser.also_keyword_return);

		object IDENTIFIER1079_tree=null;

		try { DebugEnterRule(GrammarFileName, "identifier");
		DebugLocation(1029, 27);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 300)) { return retval; }
			// cs.g:1029:18: ( IDENTIFIER | also_keyword )
			int alt271=2;
			try { DebugEnterDecision(271, decisionCanBacktrack[271]);
			int LA271_0 = input.LA(1);

			if ((LA271_0==IDENTIFIER))
			{
				alt271=1;
			}
			else if (((LA271_0>=ELIF && LA271_0<=UNDEF)||LA271_0==65||(LA271_0>=132 && LA271_0<=133)||(LA271_0>=135 && LA271_0<=148)||(LA271_0>=150 && LA271_0<=152)||LA271_0==154||(LA271_0>=156 && LA271_0<=159)||LA271_0==170||(LA271_0>=177 && LA271_0<=178)||LA271_0==195||LA271_0==202))
			{
				alt271=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 271, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(271); }
			switch (alt271)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:1030:3: IDENTIFIER
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(1030, 3);
				IDENTIFIER1079=(IToken)Match(input,IDENTIFIER,Follow._IDENTIFIER_in_identifier8261); if (state.failed) return retval;
				if ( state.backtracking==0 ) {
				IDENTIFIER1079_tree = (object)adaptor.Create(IDENTIFIER1079);
				adaptor.AddChild(root_0, IDENTIFIER1079_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:1030:16: also_keyword
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(1030, 16);
				PushFollow(Follow._also_keyword_in_identifier8265);
				also_keyword1080=also_keyword();
				PopFollow();
				if (state.failed) return retval;
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, also_keyword1080.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("identifier", 300);
			LeaveRule("identifier", 300);
			Leave_identifier();
			if (state.backtracking > 0) { Memoize(input, 300, identifier_StartIndex); }
		}
		DebugLocation(1030, 27);
		} finally { DebugExitRule(GrammarFileName, "identifier"); }
		return retval;

	}
	// $ANTLR end "identifier"

	public class keyword_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_keyword();
	partial void Leave_keyword();

	// $ANTLR start "keyword"
	// cs.g:1032:8: public keyword : ( 'abstract' | 'as' | 'base' | 'bool' | 'break' | 'byte' | 'case' | 'catch' | 'char' | 'checked' | 'class' | 'const' | 'continue' | 'decimal' | 'default' | 'delegate' | 'do' | 'double' | 'else' | 'enum' | 'event' | 'explicit' | 'extern' | 'false' | 'finally' | 'fixed' | 'float' | 'for' | 'foreach' | 'goto' | 'if' | 'implicit' | 'in' | 'int' | 'interface' | 'internal' | 'is' | 'lock' | 'long' | 'namespace' | 'new' | 'null' | 'object' | 'operator' | 'out' | 'override' | 'params' | 'private' | 'protected' | 'public' | 'readonly' | 'ref' | 'return' | 'sbyte' | 'sealed' | 'short' | 'sizeof' | 'stackalloc' | 'static' | 'string' | 'struct' | 'switch' | 'this' | 'throw' | 'true' | 'try' | 'typeof' | 'uint' | 'ulong' | 'unchecked' | 'unsafe' | 'ushort' | 'using' | 'virtual' | 'void' | 'volatile' );
	[GrammarRule("keyword")]
	public csParser.keyword_return keyword()
	{
		Enter_keyword();
		EnterRule("keyword", 301);
		TraceIn("keyword", 301);
		csParser.keyword_return retval = new csParser.keyword_return();
		retval.Start = (IToken)input.LT(1);
		int keyword_StartIndex = input.Index;
		object root_0 = null;

		IToken set1081=null;

		object set1081_tree=null;

		try { DebugEnterRule(GrammarFileName, "keyword");
		DebugLocation(1032, 800);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 301)) { return retval; }
			// cs.g:1032:15: ( 'abstract' | 'as' | 'base' | 'bool' | 'break' | 'byte' | 'case' | 'catch' | 'char' | 'checked' | 'class' | 'const' | 'continue' | 'decimal' | 'default' | 'delegate' | 'do' | 'double' | 'else' | 'enum' | 'event' | 'explicit' | 'extern' | 'false' | 'finally' | 'fixed' | 'float' | 'for' | 'foreach' | 'goto' | 'if' | 'implicit' | 'in' | 'int' | 'interface' | 'internal' | 'is' | 'lock' | 'long' | 'namespace' | 'new' | 'null' | 'object' | 'operator' | 'out' | 'override' | 'params' | 'private' | 'protected' | 'public' | 'readonly' | 'ref' | 'return' | 'sbyte' | 'sealed' | 'short' | 'sizeof' | 'stackalloc' | 'static' | 'string' | 'struct' | 'switch' | 'this' | 'throw' | 'true' | 'try' | 'typeof' | 'uint' | 'ulong' | 'unchecked' | 'unsafe' | 'ushort' | 'using' | 'virtual' | 'void' | 'volatile' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1032, 15);
			set1081=(IToken)input.LT(1);
			if ((input.LA(1)>=TRUE && input.LA(1)<=NULL)||(input.LA(1)>=USING && input.LA(1)<=IF)||input.LA(1)==61||input.LA(1)==64||(input.LA(1)>=68 && input.LA(1)<=84)||(input.LA(1)>=93 && input.LA(1)<=100)||(input.LA(1)>=122 && input.LA(1)<=123)||input.LA(1)==134||input.LA(1)==149||input.LA(1)==153||input.LA(1)==155||(input.LA(1)>=160 && input.LA(1)<=169)||(input.LA(1)>=171 && input.LA(1)<=176)||(input.LA(1)>=179 && input.LA(1)<=182)||(input.LA(1)>=184 && input.LA(1)<=194)||(input.LA(1)>=196 && input.LA(1)<=201))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set1081));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("keyword", 301);
			LeaveRule("keyword", 301);
			Leave_keyword();
			if (state.backtracking > 0) { Memoize(input, 301, keyword_StartIndex); }
		}
		DebugLocation(1033, 800);
		} finally { DebugExitRule(GrammarFileName, "keyword"); }
		return retval;

	}
	// $ANTLR end "keyword"

	public class also_keyword_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_also_keyword();
	partial void Leave_also_keyword();

	// $ANTLR start "also_keyword"
	// cs.g:1035:8: public also_keyword : ( 'add' | 'alias' | 'assembly' | 'module' | 'field' | 'method' | 'param' | 'property' | 'type' | 'yield' | 'from' | 'into' | 'join' | 'on' | 'where' | 'orderby' | 'group' | 'by' | 'ascending' | 'descending' | 'equals' | 'select' | 'pragma' | 'let' | 'remove' | 'get' | 'set' | 'var' | '__arglist' | 'dynamic' | 'elif' | 'endif' | 'define' | 'undef' );
	[GrammarRule("also_keyword")]
	public csParser.also_keyword_return also_keyword()
	{
		Enter_also_keyword();
		EnterRule("also_keyword", 302);
		TraceIn("also_keyword", 302);
		csParser.also_keyword_return retval = new csParser.also_keyword_return();
		retval.Start = (IToken)input.LT(1);
		int also_keyword_StartIndex = input.Index;
		object root_0 = null;

		IToken set1082=null;

		object set1082_tree=null;

		try { DebugEnterRule(GrammarFileName, "also_keyword");
		DebugLocation(1035, 31);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 302)) { return retval; }
			// cs.g:1035:20: ( 'add' | 'alias' | 'assembly' | 'module' | 'field' | 'method' | 'param' | 'property' | 'type' | 'yield' | 'from' | 'into' | 'join' | 'on' | 'where' | 'orderby' | 'group' | 'by' | 'ascending' | 'descending' | 'equals' | 'select' | 'pragma' | 'let' | 'remove' | 'get' | 'set' | 'var' | '__arglist' | 'dynamic' | 'elif' | 'endif' | 'define' | 'undef' )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1035, 20);
			set1082=(IToken)input.LT(1);
			if ((input.LA(1)>=ELIF && input.LA(1)<=UNDEF)||input.LA(1)==65||(input.LA(1)>=132 && input.LA(1)<=133)||(input.LA(1)>=135 && input.LA(1)<=148)||(input.LA(1)>=150 && input.LA(1)<=152)||input.LA(1)==154||(input.LA(1)>=156 && input.LA(1)<=159)||input.LA(1)==170||(input.LA(1)>=177 && input.LA(1)<=178)||input.LA(1)==195||input.LA(1)==202)
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set1082));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("also_keyword", 302);
			LeaveRule("also_keyword", 302);
			Leave_also_keyword();
			if (state.backtracking > 0) { Memoize(input, 302, also_keyword_StartIndex); }
		}
		DebugLocation(1039, 31);
		} finally { DebugExitRule(GrammarFileName, "also_keyword"); }
		return retval;

	}
	// $ANTLR end "also_keyword"

	public class literal_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_literal();
	partial void Leave_literal();

	// $ANTLR start "literal"
	// cs.g:1041:8: public literal : ( Real_literal | NUMBER | Hex_number | Character_literal | STRINGLITERAL | Verbatim_string_literal | TRUE | FALSE | NULL );
	[GrammarRule("literal")]
	public csParser.literal_return literal()
	{
		Enter_literal();
		EnterRule("literal", 303);
		TraceIn("literal", 303);
		csParser.literal_return retval = new csParser.literal_return();
		retval.Start = (IToken)input.LT(1);
		int literal_StartIndex = input.Index;
		object root_0 = null;

		IToken set1083=null;

		object set1083_tree=null;

		try { DebugEnterRule(GrammarFileName, "literal");
		DebugLocation(1041, 1);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 303)) { return retval; }
			// cs.g:1041:15: ( Real_literal | NUMBER | Hex_number | Character_literal | STRINGLITERAL | Verbatim_string_literal | TRUE | FALSE | NULL )
			DebugEnterAlt(1);
			// cs.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1041, 15);
			set1083=(IToken)input.LT(1);
			if ((input.LA(1)>=Real_literal && input.LA(1)<=NULL))
			{
				input.Consume();
				if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set1083));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("literal", 303);
			LeaveRule("literal", 303);
			Leave_literal();
			if (state.backtracking > 0) { Memoize(input, 303, literal_StartIndex); }
		}
		DebugLocation(1051, 1);
		} finally { DebugExitRule(GrammarFileName, "literal"); }
		return retval;

	}
	// $ANTLR end "literal"

	public class assignment_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_assignment_list();
	partial void Leave_assignment_list();

	// $ANTLR start "assignment_list"
	// cs.g:1321:8: public assignment_list : ( assignment ';' )+ ;
	[GrammarRule("assignment_list")]
	public csParser.assignment_list_return assignment_list()
	{
		Enter_assignment_list();
		EnterRule("assignment_list", 304);
		TraceIn("assignment_list", 304);
		csParser.assignment_list_return retval = new csParser.assignment_list_return();
		retval.Start = (IToken)input.LT(1);
		int assignment_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal1085=null;
		csParser.assignment_return assignment1084 = default(csParser.assignment_return);

		object char_literal1085_tree=null;

		try { DebugEnterRule(GrammarFileName, "assignment_list");
		DebugLocation(1321, 19);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 304)) { return retval; }
			// cs.g:1321:23: ( ( assignment ';' )+ )
			DebugEnterAlt(1);
			// cs.g:1322:2: ( assignment ';' )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1322, 2);
			// cs.g:1322:2: ( assignment ';' )+
			int cnt272=0;
			try { DebugEnterSubRule(272);
			while (true)
			{
				int alt272=2;
				try { DebugEnterDecision(272, decisionCanBacktrack[272]);
				int LA272_0 = input.LA(1);

				if (((LA272_0>=IDENTIFIER && LA272_0<=NULL)||LA272_0==MINUS||(LA272_0>=ELIF && LA272_0<=UNDEF)||LA272_0==65||LA272_0==68||(LA272_0>=83 && LA272_0<=84)||(LA272_0>=86 && LA272_0<=87)||LA272_0==90||(LA272_0>=95 && LA272_0<=100)||LA272_0==102||(LA272_0>=104 && LA272_0<=106)||LA272_0==117||(LA272_0>=132 && LA272_0<=133)||(LA272_0>=135 && LA272_0<=148)||(LA272_0>=150 && LA272_0<=152)||LA272_0==154||(LA272_0>=156 && LA272_0<=168)||LA272_0==170||(LA272_0>=177 && LA272_0<=178)||(LA272_0>=195 && LA272_0<=202)))
				{
					alt272=1;
				}


				} finally { DebugExitDecision(272); }
				switch (alt272)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1322:3: assignment ';'
					{
					DebugLocation(1322, 3);
					PushFollow(Follow._assignment_in_assignment_list10780);
					assignment1084=assignment();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignment1084.Tree);
					DebugLocation(1322, 14);
					char_literal1085=(IToken)Match(input,SEMI,Follow._SEMI_in_assignment_list10782); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal1085_tree = (object)adaptor.Create(char_literal1085);
					adaptor.AddChild(root_0, char_literal1085_tree);
					}

					}
					break;

				default:
					if (cnt272 >= 1)
						goto loop272;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee272 = new EarlyExitException( 272, input );
					DebugRecognitionException(eee272);
					throw eee272;
				}
				cnt272++;
			}
			loop272:
				;

			} finally { DebugExitSubRule(272); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("assignment_list", 304);
			LeaveRule("assignment_list", 304);
			Leave_assignment_list();
			if (state.backtracking > 0) { Memoize(input, 304, assignment_list_StartIndex); }
		}
		DebugLocation(1322, 19);
		} finally { DebugExitRule(GrammarFileName, "assignment_list"); }
		return retval;

	}
	// $ANTLR end "assignment_list"

	public class field_declarations_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_field_declarations();
	partial void Leave_field_declarations();

	// $ANTLR start "field_declarations"
	// cs.g:1323:8: public field_declarations : ( ( attributes )? ( modifiers )? type field_declaration )+ ;
	[GrammarRule("field_declarations")]
	public csParser.field_declarations_return field_declarations()
	{
		Enter_field_declarations();
		EnterRule("field_declarations", 305);
		TraceIn("field_declarations", 305);
		csParser.field_declarations_return retval = new csParser.field_declarations_return();
		retval.Start = (IToken)input.LT(1);
		int field_declarations_StartIndex = input.Index;
		object root_0 = null;

		csParser.attributes_return attributes1086 = default(csParser.attributes_return);
		csParser.modifiers_return modifiers1087 = default(csParser.modifiers_return);
		csParser.type_return type1088 = default(csParser.type_return);
		csParser.field_declaration_return field_declaration1089 = default(csParser.field_declaration_return);


		try { DebugEnterRule(GrammarFileName, "field_declarations");
		DebugLocation(1323, 56);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 305)) { return retval; }
			// cs.g:1323:26: ( ( ( attributes )? ( modifiers )? type field_declaration )+ )
			DebugEnterAlt(1);
			// cs.g:1324:2: ( ( attributes )? ( modifiers )? type field_declaration )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1324, 2);
			// cs.g:1324:2: ( ( attributes )? ( modifiers )? type field_declaration )+
			int cnt275=0;
			try { DebugEnterSubRule(275);
			while (true)
			{
				int alt275=2;
				try { DebugEnterDecision(275, decisionCanBacktrack[275]);
				int LA275_0 = input.LA(1);

				if ((LA275_0==IDENTIFIER||(LA275_0>=ELIF && LA275_0<=UNDEF)||(LA275_0>=64 && LA275_0<=65)||(LA275_0>=68 && LA275_0<=80)||LA275_0==82||LA275_0==88||(LA275_0>=132 && LA275_0<=133)||(LA275_0>=135 && LA275_0<=148)||(LA275_0>=150 && LA275_0<=152)||LA275_0==154||(LA275_0>=156 && LA275_0<=168)||LA275_0==170||(LA275_0>=177 && LA275_0<=178)||(LA275_0>=195 && LA275_0<=202)))
				{
					alt275=1;
				}


				} finally { DebugExitDecision(275); }
				switch (alt275)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1324:3: ( attributes )? ( modifiers )? type field_declaration
					{
					DebugLocation(1324, 3);
					// cs.g:1324:3: ( attributes )?
					int alt273=2;
					try { DebugEnterSubRule(273);
					try { DebugEnterDecision(273, decisionCanBacktrack[273]);
					int LA273_0 = input.LA(1);

					if ((LA273_0==88))
					{
						alt273=1;
					}
					} finally { DebugExitDecision(273); }
					switch (alt273)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:1324:3: attributes
						{
						DebugLocation(1324, 3);
						PushFollow(Follow._attributes_in_field_declarations10795);
						attributes1086=attributes();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes1086.Tree);

						}
						break;

					}
					} finally { DebugExitSubRule(273); }

					DebugLocation(1324, 17);
					// cs.g:1324:17: ( modifiers )?
					int alt274=2;
					try { DebugEnterSubRule(274);
					try { DebugEnterDecision(274, decisionCanBacktrack[274]);
					int LA274_0 = input.LA(1);

					if ((LA274_0==64||(LA274_0>=68 && LA274_0<=80)))
					{
						alt274=1;
					}
					} finally { DebugExitDecision(274); }
					switch (alt274)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:1324:17: modifiers
						{
						DebugLocation(1324, 17);
						PushFollow(Follow._modifiers_in_field_declarations10800);
						modifiers1087=modifiers();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers1087.Tree);

						}
						break;

					}
					} finally { DebugExitSubRule(274); }

					DebugLocation(1324, 30);
					PushFollow(Follow._type_in_field_declarations10805);
					type1088=type();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type1088.Tree);
					DebugLocation(1324, 37);
					PushFollow(Follow._field_declaration_in_field_declarations10809);
					field_declaration1089=field_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, field_declaration1089.Tree);

					}
					break;

				default:
					if (cnt275 >= 1)
						goto loop275;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee275 = new EarlyExitException( 275, input );
					DebugRecognitionException(eee275);
					throw eee275;
				}
				cnt275++;
			}
			loop275:
				;

			} finally { DebugExitSubRule(275); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("field_declarations", 305);
			LeaveRule("field_declarations", 305);
			Leave_field_declarations();
			if (state.backtracking > 0) { Memoize(input, 305, field_declarations_StartIndex); }
		}
		DebugLocation(1324, 56);
		} finally { DebugExitRule(GrammarFileName, "field_declarations"); }
		return retval;

	}
	// $ANTLR end "field_declarations"

	public class property_declaration_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_property_declaration_list();
	partial void Leave_property_declaration_list();

	// $ANTLR start "property_declaration_list"
	// cs.g:1325:8: public property_declaration_list : ( ( attributes )? ( modifiers )? type property_declaration )+ ;
	[GrammarRule("property_declaration_list")]
	public csParser.property_declaration_list_return property_declaration_list()
	{
		Enter_property_declaration_list();
		EnterRule("property_declaration_list", 306);
		TraceIn("property_declaration_list", 306);
		csParser.property_declaration_list_return retval = new csParser.property_declaration_list_return();
		retval.Start = (IToken)input.LT(1);
		int property_declaration_list_StartIndex = input.Index;
		object root_0 = null;

		csParser.attributes_return attributes1090 = default(csParser.attributes_return);
		csParser.modifiers_return modifiers1091 = default(csParser.modifiers_return);
		csParser.type_return type1092 = default(csParser.type_return);
		csParser.property_declaration_return property_declaration1093 = default(csParser.property_declaration_return);


		try { DebugEnterRule(GrammarFileName, "property_declaration_list");
		DebugLocation(1325, 59);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 306)) { return retval; }
			// cs.g:1325:33: ( ( ( attributes )? ( modifiers )? type property_declaration )+ )
			DebugEnterAlt(1);
			// cs.g:1326:2: ( ( attributes )? ( modifiers )? type property_declaration )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1326, 2);
			// cs.g:1326:2: ( ( attributes )? ( modifiers )? type property_declaration )+
			int cnt278=0;
			try { DebugEnterSubRule(278);
			while (true)
			{
				int alt278=2;
				try { DebugEnterDecision(278, decisionCanBacktrack[278]);
				int LA278_0 = input.LA(1);

				if ((LA278_0==IDENTIFIER||(LA278_0>=ELIF && LA278_0<=UNDEF)||(LA278_0>=64 && LA278_0<=65)||(LA278_0>=68 && LA278_0<=80)||LA278_0==82||LA278_0==88||(LA278_0>=132 && LA278_0<=133)||(LA278_0>=135 && LA278_0<=148)||(LA278_0>=150 && LA278_0<=152)||LA278_0==154||(LA278_0>=156 && LA278_0<=168)||LA278_0==170||(LA278_0>=177 && LA278_0<=178)||(LA278_0>=195 && LA278_0<=202)))
				{
					alt278=1;
				}


				} finally { DebugExitDecision(278); }
				switch (alt278)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1326:3: ( attributes )? ( modifiers )? type property_declaration
					{
					DebugLocation(1326, 3);
					// cs.g:1326:3: ( attributes )?
					int alt276=2;
					try { DebugEnterSubRule(276);
					try { DebugEnterDecision(276, decisionCanBacktrack[276]);
					int LA276_0 = input.LA(1);

					if ((LA276_0==88))
					{
						alt276=1;
					}
					} finally { DebugExitDecision(276); }
					switch (alt276)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:1326:3: attributes
						{
						DebugLocation(1326, 3);
						PushFollow(Follow._attributes_in_property_declaration_list10822);
						attributes1090=attributes();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes1090.Tree);

						}
						break;

					}
					} finally { DebugExitSubRule(276); }

					DebugLocation(1326, 17);
					// cs.g:1326:17: ( modifiers )?
					int alt277=2;
					try { DebugEnterSubRule(277);
					try { DebugEnterDecision(277, decisionCanBacktrack[277]);
					int LA277_0 = input.LA(1);

					if ((LA277_0==64||(LA277_0>=68 && LA277_0<=80)))
					{
						alt277=1;
					}
					} finally { DebugExitDecision(277); }
					switch (alt277)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:1326:17: modifiers
						{
						DebugLocation(1326, 17);
						PushFollow(Follow._modifiers_in_property_declaration_list10827);
						modifiers1091=modifiers();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers1091.Tree);

						}
						break;

					}
					} finally { DebugExitSubRule(277); }

					DebugLocation(1326, 30);
					PushFollow(Follow._type_in_property_declaration_list10832);
					type1092=type();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type1092.Tree);
					DebugLocation(1326, 37);
					PushFollow(Follow._property_declaration_in_property_declaration_list10836);
					property_declaration1093=property_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, property_declaration1093.Tree);

					}
					break;

				default:
					if (cnt278 >= 1)
						goto loop278;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee278 = new EarlyExitException( 278, input );
					DebugRecognitionException(eee278);
					throw eee278;
				}
				cnt278++;
			}
			loop278:
				;

			} finally { DebugExitSubRule(278); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("property_declaration_list", 306);
			LeaveRule("property_declaration_list", 306);
			Leave_property_declaration_list();
			if (state.backtracking > 0) { Memoize(input, 306, property_declaration_list_StartIndex); }
		}
		DebugLocation(1326, 59);
		} finally { DebugExitRule(GrammarFileName, "property_declaration_list"); }
		return retval;

	}
	// $ANTLR end "property_declaration_list"

	public class constant_declarations_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_constant_declarations();
	partial void Leave_constant_declarations();

	// $ANTLR start "constant_declarations"
	// cs.g:1327:8: public constant_declarations : ( constant_declaration )+ ;
	[GrammarRule("constant_declarations")]
	public csParser.constant_declarations_return constant_declarations()
	{
		Enter_constant_declarations();
		EnterRule("constant_declarations", 307);
		TraceIn("constant_declarations", 307);
		csParser.constant_declarations_return retval = new csParser.constant_declarations_return();
		retval.Start = (IToken)input.LT(1);
		int constant_declarations_StartIndex = input.Index;
		object root_0 = null;

		csParser.constant_declaration_return constant_declaration1094 = default(csParser.constant_declaration_return);


		try { DebugEnterRule(GrammarFileName, "constant_declarations");
		DebugLocation(1327, 22);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 307)) { return retval; }
			// cs.g:1327:29: ( ( constant_declaration )+ )
			DebugEnterAlt(1);
			// cs.g:1328:2: ( constant_declaration )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1328, 2);
			// cs.g:1328:2: ( constant_declaration )+
			int cnt279=0;
			try { DebugEnterSubRule(279);
			while (true)
			{
				int alt279=2;
				try { DebugEnterDecision(279, decisionCanBacktrack[279]);
				int LA279_0 = input.LA(1);

				if ((LA279_0==81))
				{
					alt279=1;
				}


				} finally { DebugExitDecision(279); }
				switch (alt279)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1328:2: constant_declaration
					{
					DebugLocation(1328, 2);
					PushFollow(Follow._constant_declaration_in_constant_declarations10848);
					constant_declaration1094=constant_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declaration1094.Tree);

					}
					break;

				default:
					if (cnt279 >= 1)
						goto loop279;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee279 = new EarlyExitException( 279, input );
					DebugRecognitionException(eee279);
					throw eee279;
				}
				cnt279++;
			}
			loop279:
				;

			} finally { DebugExitSubRule(279); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("constant_declarations", 307);
			LeaveRule("constant_declarations", 307);
			Leave_constant_declarations();
			if (state.backtracking > 0) { Memoize(input, 307, constant_declarations_StartIndex); }
		}
		DebugLocation(1328, 22);
		} finally { DebugExitRule(GrammarFileName, "constant_declarations"); }
		return retval;

	}
	// $ANTLR end "constant_declarations"

	public class literals_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_literals();
	partial void Leave_literals();

	// $ANTLR start "literals"
	// cs.g:1329:8: public literals : ( literal )+ ;
	[GrammarRule("literals")]
	public csParser.literals_return literals()
	{
		Enter_literals();
		EnterRule("literals", 308);
		TraceIn("literals", 308);
		csParser.literals_return retval = new csParser.literals_return();
		retval.Start = (IToken)input.LT(1);
		int literals_StartIndex = input.Index;
		object root_0 = null;

		csParser.literal_return literal1095 = default(csParser.literal_return);


		try { DebugEnterRule(GrammarFileName, "literals");
		DebugLocation(1329, 10);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 308)) { return retval; }
			// cs.g:1329:16: ( ( literal )+ )
			DebugEnterAlt(1);
			// cs.g:1330:2: ( literal )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1330, 2);
			// cs.g:1330:2: ( literal )+
			int cnt280=0;
			try { DebugEnterSubRule(280);
			while (true)
			{
				int alt280=2;
				try { DebugEnterDecision(280, decisionCanBacktrack[280]);
				int LA280_0 = input.LA(1);

				if (((LA280_0>=Real_literal && LA280_0<=NULL)))
				{
					alt280=1;
				}


				} finally { DebugExitDecision(280); }
				switch (alt280)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1330:2: literal
					{
					DebugLocation(1330, 2);
					PushFollow(Follow._literal_in_literals10858);
					literal1095=literal();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, literal1095.Tree);

					}
					break;

				default:
					if (cnt280 >= 1)
						goto loop280;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee280 = new EarlyExitException( 280, input );
					DebugRecognitionException(eee280);
					throw eee280;
				}
				cnt280++;
			}
			loop280:
				;

			} finally { DebugExitSubRule(280); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("literals", 308);
			LeaveRule("literals", 308);
			Leave_literals();
			if (state.backtracking > 0) { Memoize(input, 308, literals_StartIndex); }
		}
		DebugLocation(1330, 10);
		} finally { DebugExitRule(GrammarFileName, "literals"); }
		return retval;

	}
	// $ANTLR end "literals"

	public class delegate_declaration_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_delegate_declaration_list();
	partial void Leave_delegate_declaration_list();

	// $ANTLR start "delegate_declaration_list"
	// cs.g:1331:8: public delegate_declaration_list : ( ( attributes )? ( modifiers )? delegate_declaration )+ ;
	[GrammarRule("delegate_declaration_list")]
	public csParser.delegate_declaration_list_return delegate_declaration_list()
	{
		Enter_delegate_declaration_list();
		EnterRule("delegate_declaration_list", 309);
		TraceIn("delegate_declaration_list", 309);
		csParser.delegate_declaration_list_return retval = new csParser.delegate_declaration_list_return();
		retval.Start = (IToken)input.LT(1);
		int delegate_declaration_list_StartIndex = input.Index;
		object root_0 = null;

		csParser.attributes_return attributes1096 = default(csParser.attributes_return);
		csParser.modifiers_return modifiers1097 = default(csParser.modifiers_return);
		csParser.delegate_declaration_return delegate_declaration1098 = default(csParser.delegate_declaration_return);


		try { DebugEnterRule(GrammarFileName, "delegate_declaration_list");
		DebugLocation(1331, 52);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 309)) { return retval; }
			// cs.g:1331:33: ( ( ( attributes )? ( modifiers )? delegate_declaration )+ )
			DebugEnterAlt(1);
			// cs.g:1332:2: ( ( attributes )? ( modifiers )? delegate_declaration )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1332, 2);
			// cs.g:1332:2: ( ( attributes )? ( modifiers )? delegate_declaration )+
			int cnt283=0;
			try { DebugEnterSubRule(283);
			while (true)
			{
				int alt283=2;
				try { DebugEnterDecision(283, decisionCanBacktrack[283]);
				int LA283_0 = input.LA(1);

				if ((LA283_0==64||(LA283_0>=68 && LA283_0<=80)||LA283_0==88||LA283_0==99))
				{
					alt283=1;
				}


				} finally { DebugExitDecision(283); }
				switch (alt283)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1332:3: ( attributes )? ( modifiers )? delegate_declaration
					{
					DebugLocation(1332, 3);
					// cs.g:1332:3: ( attributes )?
					int alt281=2;
					try { DebugEnterSubRule(281);
					try { DebugEnterDecision(281, decisionCanBacktrack[281]);
					int LA281_0 = input.LA(1);

					if ((LA281_0==88))
					{
						alt281=1;
					}
					} finally { DebugExitDecision(281); }
					switch (alt281)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:1332:3: attributes
						{
						DebugLocation(1332, 3);
						PushFollow(Follow._attributes_in_delegate_declaration_list10870);
						attributes1096=attributes();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes1096.Tree);

						}
						break;

					}
					} finally { DebugExitSubRule(281); }

					DebugLocation(1332, 17);
					// cs.g:1332:17: ( modifiers )?
					int alt282=2;
					try { DebugEnterSubRule(282);
					try { DebugEnterDecision(282, decisionCanBacktrack[282]);
					int LA282_0 = input.LA(1);

					if ((LA282_0==64||(LA282_0>=68 && LA282_0<=80)))
					{
						alt282=1;
					}
					} finally { DebugExitDecision(282); }
					switch (alt282)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:1332:17: modifiers
						{
						DebugLocation(1332, 17);
						PushFollow(Follow._modifiers_in_delegate_declaration_list10875);
						modifiers1097=modifiers();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers1097.Tree);

						}
						break;

					}
					} finally { DebugExitSubRule(282); }

					DebugLocation(1332, 30);
					PushFollow(Follow._delegate_declaration_in_delegate_declaration_list10880);
					delegate_declaration1098=delegate_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, delegate_declaration1098.Tree);

					}
					break;

				default:
					if (cnt283 >= 1)
						goto loop283;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee283 = new EarlyExitException( 283, input );
					DebugRecognitionException(eee283);
					throw eee283;
				}
				cnt283++;
			}
			loop283:
				;

			} finally { DebugExitSubRule(283); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("delegate_declaration_list", 309);
			LeaveRule("delegate_declaration_list", 309);
			Leave_delegate_declaration_list();
			if (state.backtracking > 0) { Memoize(input, 309, delegate_declaration_list_StartIndex); }
		}
		DebugLocation(1332, 52);
		} finally { DebugExitRule(GrammarFileName, "delegate_declaration_list"); }
		return retval;

	}
	// $ANTLR end "delegate_declaration_list"

	public class local_variable_declaration_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_local_variable_declaration_list();
	partial void Leave_local_variable_declaration_list();

	// $ANTLR start "local_variable_declaration_list"
	// cs.g:1333:8: public local_variable_declaration_list : ( local_variable_declaration ';' )+ ;
	[GrammarRule("local_variable_declaration_list")]
	public csParser.local_variable_declaration_list_return local_variable_declaration_list()
	{
		Enter_local_variable_declaration_list();
		EnterRule("local_variable_declaration_list", 310);
		TraceIn("local_variable_declaration_list", 310);
		csParser.local_variable_declaration_list_return retval = new csParser.local_variable_declaration_list_return();
		retval.Start = (IToken)input.LT(1);
		int local_variable_declaration_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal1100=null;
		csParser.local_variable_declaration_return local_variable_declaration1099 = default(csParser.local_variable_declaration_return);

		object char_literal1100_tree=null;

		try { DebugEnterRule(GrammarFileName, "local_variable_declaration_list");
		DebugLocation(1333, 35);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 310)) { return retval; }
			// cs.g:1333:39: ( ( local_variable_declaration ';' )+ )
			DebugEnterAlt(1);
			// cs.g:1334:2: ( local_variable_declaration ';' )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1334, 2);
			// cs.g:1334:2: ( local_variable_declaration ';' )+
			int cnt284=0;
			try { DebugEnterSubRule(284);
			while (true)
			{
				int alt284=2;
				try { DebugEnterDecision(284, decisionCanBacktrack[284]);
				int LA284_0 = input.LA(1);

				if ((LA284_0==IDENTIFIER||(LA284_0>=ELIF && LA284_0<=UNDEF)||LA284_0==65||LA284_0==82||(LA284_0>=132 && LA284_0<=133)||(LA284_0>=135 && LA284_0<=148)||(LA284_0>=150 && LA284_0<=152)||LA284_0==154||(LA284_0>=156 && LA284_0<=168)||LA284_0==170||(LA284_0>=177 && LA284_0<=178)||(LA284_0>=195 && LA284_0<=202)))
				{
					alt284=1;
				}


				} finally { DebugExitDecision(284); }
				switch (alt284)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1334:3: local_variable_declaration ';'
					{
					DebugLocation(1334, 3);
					PushFollow(Follow._local_variable_declaration_in_local_variable_declaration_list10893);
					local_variable_declaration1099=local_variable_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declaration1099.Tree);
					DebugLocation(1334, 30);
					char_literal1100=(IToken)Match(input,SEMI,Follow._SEMI_in_local_variable_declaration_list10895); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal1100_tree = (object)adaptor.Create(char_literal1100);
					adaptor.AddChild(root_0, char_literal1100_tree);
					}

					}
					break;

				default:
					if (cnt284 >= 1)
						goto loop284;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee284 = new EarlyExitException( 284, input );
					DebugRecognitionException(eee284);
					throw eee284;
				}
				cnt284++;
			}
			loop284:
				;

			} finally { DebugExitSubRule(284); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("local_variable_declaration_list", 310);
			LeaveRule("local_variable_declaration_list", 310);
			Leave_local_variable_declaration_list();
			if (state.backtracking > 0) { Memoize(input, 310, local_variable_declaration_list_StartIndex); }
		}
		DebugLocation(1334, 35);
		} finally { DebugExitRule(GrammarFileName, "local_variable_declaration_list"); }
		return retval;

	}
	// $ANTLR end "local_variable_declaration_list"

	public class local_variable_initializer_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_local_variable_initializer_list();
	partial void Leave_local_variable_initializer_list();

	// $ANTLR start "local_variable_initializer_list"
	// cs.g:1335:8: public local_variable_initializer_list : ( local_variable_initializer ';' )+ ;
	[GrammarRule("local_variable_initializer_list")]
	public csParser.local_variable_initializer_list_return local_variable_initializer_list()
	{
		Enter_local_variable_initializer_list();
		EnterRule("local_variable_initializer_list", 311);
		TraceIn("local_variable_initializer_list", 311);
		csParser.local_variable_initializer_list_return retval = new csParser.local_variable_initializer_list_return();
		retval.Start = (IToken)input.LT(1);
		int local_variable_initializer_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal1102=null;
		csParser.local_variable_initializer_return local_variable_initializer1101 = default(csParser.local_variable_initializer_return);

		object char_literal1102_tree=null;

		try { DebugEnterRule(GrammarFileName, "local_variable_initializer_list");
		DebugLocation(1335, 35);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 311)) { return retval; }
			// cs.g:1335:39: ( ( local_variable_initializer ';' )+ )
			DebugEnterAlt(1);
			// cs.g:1336:2: ( local_variable_initializer ';' )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1336, 2);
			// cs.g:1336:2: ( local_variable_initializer ';' )+
			int cnt285=0;
			try { DebugEnterSubRule(285);
			while (true)
			{
				int alt285=2;
				try { DebugEnterDecision(285, decisionCanBacktrack[285]);
				int LA285_0 = input.LA(1);

				if (((LA285_0>=IDENTIFIER && LA285_0<=NULL)||LA285_0==MINUS||(LA285_0>=ELIF && LA285_0<=UNDEF)||LA285_0==62||LA285_0==65||LA285_0==68||(LA285_0>=83 && LA285_0<=84)||(LA285_0>=86 && LA285_0<=87)||LA285_0==90||(LA285_0>=95 && LA285_0<=100)||LA285_0==102||(LA285_0>=104 && LA285_0<=106)||LA285_0==117||(LA285_0>=132 && LA285_0<=133)||(LA285_0>=135 && LA285_0<=148)||(LA285_0>=150 && LA285_0<=152)||LA285_0==154||(LA285_0>=156 && LA285_0<=168)||LA285_0==170||(LA285_0>=177 && LA285_0<=179)||(LA285_0>=195 && LA285_0<=202)))
				{
					alt285=1;
				}


				} finally { DebugExitDecision(285); }
				switch (alt285)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1336:3: local_variable_initializer ';'
					{
					DebugLocation(1336, 3);
					PushFollow(Follow._local_variable_initializer_in_local_variable_initializer_list10908);
					local_variable_initializer1101=local_variable_initializer();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_initializer1101.Tree);
					DebugLocation(1336, 30);
					char_literal1102=(IToken)Match(input,SEMI,Follow._SEMI_in_local_variable_initializer_list10910); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal1102_tree = (object)adaptor.Create(char_literal1102);
					adaptor.AddChild(root_0, char_literal1102_tree);
					}

					}
					break;

				default:
					if (cnt285 >= 1)
						goto loop285;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee285 = new EarlyExitException( 285, input );
					DebugRecognitionException(eee285);
					throw eee285;
				}
				cnt285++;
			}
			loop285:
				;

			} finally { DebugExitSubRule(285); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("local_variable_initializer_list", 311);
			LeaveRule("local_variable_initializer_list", 311);
			Leave_local_variable_initializer_list();
			if (state.backtracking > 0) { Memoize(input, 311, local_variable_initializer_list_StartIndex); }
		}
		DebugLocation(1336, 35);
		} finally { DebugExitRule(GrammarFileName, "local_variable_initializer_list"); }
		return retval;

	}
	// $ANTLR end "local_variable_initializer_list"

	public class expression_list_test_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_expression_list_test();
	partial void Leave_expression_list_test();

	// $ANTLR start "expression_list_test"
	// cs.g:1337:8: public expression_list_test : ( expression ';' )+ ;
	[GrammarRule("expression_list_test")]
	public csParser.expression_list_test_return expression_list_test()
	{
		Enter_expression_list_test();
		EnterRule("expression_list_test", 312);
		TraceIn("expression_list_test", 312);
		csParser.expression_list_test_return retval = new csParser.expression_list_test_return();
		retval.Start = (IToken)input.LT(1);
		int expression_list_test_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal1104=null;
		csParser.expression_return expression1103 = default(csParser.expression_return);

		object char_literal1104_tree=null;

		try { DebugEnterRule(GrammarFileName, "expression_list_test");
		DebugLocation(1337, 19);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 312)) { return retval; }
			// cs.g:1337:28: ( ( expression ';' )+ )
			DebugEnterAlt(1);
			// cs.g:1338:2: ( expression ';' )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1338, 2);
			// cs.g:1338:2: ( expression ';' )+
			int cnt286=0;
			try { DebugEnterSubRule(286);
			while (true)
			{
				int alt286=2;
				try { DebugEnterDecision(286, decisionCanBacktrack[286]);
				int LA286_0 = input.LA(1);

				if (((LA286_0>=IDENTIFIER && LA286_0<=NULL)||LA286_0==MINUS||(LA286_0>=ELIF && LA286_0<=UNDEF)||LA286_0==65||LA286_0==68||(LA286_0>=83 && LA286_0<=84)||(LA286_0>=86 && LA286_0<=87)||LA286_0==90||(LA286_0>=95 && LA286_0<=100)||LA286_0==102||(LA286_0>=104 && LA286_0<=106)||LA286_0==117||(LA286_0>=132 && LA286_0<=133)||(LA286_0>=135 && LA286_0<=148)||(LA286_0>=150 && LA286_0<=152)||LA286_0==154||(LA286_0>=156 && LA286_0<=168)||LA286_0==170||(LA286_0>=177 && LA286_0<=178)||(LA286_0>=195 && LA286_0<=202)))
				{
					alt286=1;
				}


				} finally { DebugExitDecision(286); }
				switch (alt286)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1338:3: expression ';'
					{
					DebugLocation(1338, 3);
					PushFollow(Follow._expression_in_expression_list_test10923);
					expression1103=expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1103.Tree);
					DebugLocation(1338, 14);
					char_literal1104=(IToken)Match(input,SEMI,Follow._SEMI_in_expression_list_test10925); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal1104_tree = (object)adaptor.Create(char_literal1104);
					adaptor.AddChild(root_0, char_literal1104_tree);
					}

					}
					break;

				default:
					if (cnt286 >= 1)
						goto loop286;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee286 = new EarlyExitException( 286, input );
					DebugRecognitionException(eee286);
					throw eee286;
				}
				cnt286++;
			}
			loop286:
				;

			} finally { DebugExitSubRule(286); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("expression_list_test", 312);
			LeaveRule("expression_list_test", 312);
			Leave_expression_list_test();
			if (state.backtracking > 0) { Memoize(input, 312, expression_list_test_StartIndex); }
		}
		DebugLocation(1338, 19);
		} finally { DebugExitRule(GrammarFileName, "expression_list_test"); }
		return retval;

	}
	// $ANTLR end "expression_list_test"

	public class unary_expression_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_unary_expression_list();
	partial void Leave_unary_expression_list();

	// $ANTLR start "unary_expression_list"
	// cs.g:1339:8: public unary_expression_list : ( unary_expression ';' )+ ;
	[GrammarRule("unary_expression_list")]
	public csParser.unary_expression_list_return unary_expression_list()
	{
		Enter_unary_expression_list();
		EnterRule("unary_expression_list", 313);
		TraceIn("unary_expression_list", 313);
		csParser.unary_expression_list_return retval = new csParser.unary_expression_list_return();
		retval.Start = (IToken)input.LT(1);
		int unary_expression_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal1106=null;
		csParser.unary_expression_return unary_expression1105 = default(csParser.unary_expression_return);

		object char_literal1106_tree=null;

		try { DebugEnterRule(GrammarFileName, "unary_expression_list");
		DebugLocation(1339, 25);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 313)) { return retval; }
			// cs.g:1339:29: ( ( unary_expression ';' )+ )
			DebugEnterAlt(1);
			// cs.g:1340:2: ( unary_expression ';' )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1340, 2);
			// cs.g:1340:2: ( unary_expression ';' )+
			int cnt287=0;
			try { DebugEnterSubRule(287);
			while (true)
			{
				int alt287=2;
				try { DebugEnterDecision(287, decisionCanBacktrack[287]);
				int LA287_0 = input.LA(1);

				if (((LA287_0>=IDENTIFIER && LA287_0<=NULL)||LA287_0==MINUS||(LA287_0>=ELIF && LA287_0<=UNDEF)||LA287_0==65||LA287_0==68||(LA287_0>=83 && LA287_0<=84)||(LA287_0>=86 && LA287_0<=87)||LA287_0==90||(LA287_0>=95 && LA287_0<=100)||LA287_0==102||(LA287_0>=104 && LA287_0<=106)||LA287_0==117||(LA287_0>=132 && LA287_0<=133)||(LA287_0>=135 && LA287_0<=148)||(LA287_0>=150 && LA287_0<=152)||LA287_0==154||(LA287_0>=156 && LA287_0<=168)||LA287_0==170||(LA287_0>=177 && LA287_0<=178)||(LA287_0>=195 && LA287_0<=202)))
				{
					alt287=1;
				}


				} finally { DebugExitDecision(287); }
				switch (alt287)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1340:3: unary_expression ';'
					{
					DebugLocation(1340, 3);
					PushFollow(Follow._unary_expression_in_unary_expression_list10938);
					unary_expression1105=unary_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression1105.Tree);
					DebugLocation(1340, 20);
					char_literal1106=(IToken)Match(input,SEMI,Follow._SEMI_in_unary_expression_list10940); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal1106_tree = (object)adaptor.Create(char_literal1106);
					adaptor.AddChild(root_0, char_literal1106_tree);
					}

					}
					break;

				default:
					if (cnt287 >= 1)
						goto loop287;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee287 = new EarlyExitException( 287, input );
					DebugRecognitionException(eee287);
					throw eee287;
				}
				cnt287++;
			}
			loop287:
				;

			} finally { DebugExitSubRule(287); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("unary_expression_list", 313);
			LeaveRule("unary_expression_list", 313);
			Leave_unary_expression_list();
			if (state.backtracking > 0) { Memoize(input, 313, unary_expression_list_StartIndex); }
		}
		DebugLocation(1340, 25);
		} finally { DebugExitRule(GrammarFileName, "unary_expression_list"); }
		return retval;

	}
	// $ANTLR end "unary_expression_list"

	public class invocation_expression_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_invocation_expression_list();
	partial void Leave_invocation_expression_list();

	// $ANTLR start "invocation_expression_list"
	// cs.g:1341:8: public invocation_expression_list : ( invocation_expression ';' )+ ;
	[GrammarRule("invocation_expression_list")]
	public csParser.invocation_expression_list_return invocation_expression_list()
	{
		Enter_invocation_expression_list();
		EnterRule("invocation_expression_list", 314);
		TraceIn("invocation_expression_list", 314);
		csParser.invocation_expression_list_return retval = new csParser.invocation_expression_list_return();
		retval.Start = (IToken)input.LT(1);
		int invocation_expression_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal1108=null;
		csParser.invocation_expression_return invocation_expression1107 = default(csParser.invocation_expression_return);

		object char_literal1108_tree=null;

		try { DebugEnterRule(GrammarFileName, "invocation_expression_list");
		DebugLocation(1341, 30);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 314)) { return retval; }
			// cs.g:1341:34: ( ( invocation_expression ';' )+ )
			DebugEnterAlt(1);
			// cs.g:1342:2: ( invocation_expression ';' )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1342, 2);
			// cs.g:1342:2: ( invocation_expression ';' )+
			int cnt288=0;
			try { DebugEnterSubRule(288);
			while (true)
			{
				int alt288=2;
				try { DebugEnterDecision(288, decisionCanBacktrack[288]);
				int LA288_0 = input.LA(1);

				if ((LA288_0==IDENTIFIER||(LA288_0>=ELIF && LA288_0<=UNDEF)||LA288_0==65||(LA288_0>=83 && LA288_0<=84)||LA288_0==100||(LA288_0>=132 && LA288_0<=133)||(LA288_0>=135 && LA288_0<=148)||(LA288_0>=150 && LA288_0<=152)||LA288_0==154||(LA288_0>=156 && LA288_0<=168)||LA288_0==170||(LA288_0>=177 && LA288_0<=178)||(LA288_0>=195 && LA288_0<=202)))
				{
					alt288=1;
				}


				} finally { DebugExitDecision(288); }
				switch (alt288)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1342:3: invocation_expression ';'
					{
					DebugLocation(1342, 3);
					PushFollow(Follow._invocation_expression_in_invocation_expression_list10953);
					invocation_expression1107=invocation_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_expression1107.Tree);
					DebugLocation(1342, 25);
					char_literal1108=(IToken)Match(input,SEMI,Follow._SEMI_in_invocation_expression_list10955); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal1108_tree = (object)adaptor.Create(char_literal1108);
					adaptor.AddChild(root_0, char_literal1108_tree);
					}

					}
					break;

				default:
					if (cnt288 >= 1)
						goto loop288;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee288 = new EarlyExitException( 288, input );
					DebugRecognitionException(eee288);
					throw eee288;
				}
				cnt288++;
			}
			loop288:
				;

			} finally { DebugExitSubRule(288); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("invocation_expression_list", 314);
			LeaveRule("invocation_expression_list", 314);
			Leave_invocation_expression_list();
			if (state.backtracking > 0) { Memoize(input, 314, invocation_expression_list_StartIndex); }
		}
		DebugLocation(1342, 30);
		} finally { DebugExitRule(GrammarFileName, "invocation_expression_list"); }
		return retval;

	}
	// $ANTLR end "invocation_expression_list"

	public class primary_expression_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_primary_expression_list();
	partial void Leave_primary_expression_list();

	// $ANTLR start "primary_expression_list"
	// cs.g:1343:8: public primary_expression_list : ( primary_expression ';' )+ ;
	[GrammarRule("primary_expression_list")]
	public csParser.primary_expression_list_return primary_expression_list()
	{
		Enter_primary_expression_list();
		EnterRule("primary_expression_list", 315);
		TraceIn("primary_expression_list", 315);
		csParser.primary_expression_list_return retval = new csParser.primary_expression_list_return();
		retval.Start = (IToken)input.LT(1);
		int primary_expression_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal1110=null;
		csParser.primary_expression_return primary_expression1109 = default(csParser.primary_expression_return);

		object char_literal1110_tree=null;

		try { DebugEnterRule(GrammarFileName, "primary_expression_list");
		DebugLocation(1343, 27);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 315)) { return retval; }
			// cs.g:1343:31: ( ( primary_expression ';' )+ )
			DebugEnterAlt(1);
			// cs.g:1344:2: ( primary_expression ';' )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1344, 2);
			// cs.g:1344:2: ( primary_expression ';' )+
			int cnt289=0;
			try { DebugEnterSubRule(289);
			while (true)
			{
				int alt289=2;
				try { DebugEnterDecision(289, decisionCanBacktrack[289]);
				int LA289_0 = input.LA(1);

				if (((LA289_0>=IDENTIFIER && LA289_0<=NULL)||(LA289_0>=ELIF && LA289_0<=UNDEF)||LA289_0==65||LA289_0==68||(LA289_0>=83 && LA289_0<=84)||LA289_0==90||(LA289_0>=95 && LA289_0<=100)||(LA289_0>=132 && LA289_0<=133)||(LA289_0>=135 && LA289_0<=148)||(LA289_0>=150 && LA289_0<=152)||LA289_0==154||(LA289_0>=156 && LA289_0<=168)||LA289_0==170||(LA289_0>=177 && LA289_0<=178)||(LA289_0>=195 && LA289_0<=202)))
				{
					alt289=1;
				}


				} finally { DebugExitDecision(289); }
				switch (alt289)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1344:3: primary_expression ';'
					{
					DebugLocation(1344, 3);
					PushFollow(Follow._primary_expression_in_primary_expression_list10968);
					primary_expression1109=primary_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression1109.Tree);
					DebugLocation(1344, 22);
					char_literal1110=(IToken)Match(input,SEMI,Follow._SEMI_in_primary_expression_list10970); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal1110_tree = (object)adaptor.Create(char_literal1110);
					adaptor.AddChild(root_0, char_literal1110_tree);
					}

					}
					break;

				default:
					if (cnt289 >= 1)
						goto loop289;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee289 = new EarlyExitException( 289, input );
					DebugRecognitionException(eee289);
					throw eee289;
				}
				cnt289++;
			}
			loop289:
				;

			} finally { DebugExitSubRule(289); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("primary_expression_list", 315);
			LeaveRule("primary_expression_list", 315);
			Leave_primary_expression_list();
			if (state.backtracking > 0) { Memoize(input, 315, primary_expression_list_StartIndex); }
		}
		DebugLocation(1344, 27);
		} finally { DebugExitRule(GrammarFileName, "primary_expression_list"); }
		return retval;

	}
	// $ANTLR end "primary_expression_list"

	public class non_assignment_expression_list_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_non_assignment_expression_list();
	partial void Leave_non_assignment_expression_list();

	// $ANTLR start "non_assignment_expression_list"
	// cs.g:1345:8: public non_assignment_expression_list : ( non_assignment_expression ';' )+ ;
	[GrammarRule("non_assignment_expression_list")]
	public csParser.non_assignment_expression_list_return non_assignment_expression_list()
	{
		Enter_non_assignment_expression_list();
		EnterRule("non_assignment_expression_list", 316);
		TraceIn("non_assignment_expression_list", 316);
		csParser.non_assignment_expression_list_return retval = new csParser.non_assignment_expression_list_return();
		retval.Start = (IToken)input.LT(1);
		int non_assignment_expression_list_StartIndex = input.Index;
		object root_0 = null;

		IToken char_literal1112=null;
		csParser.non_assignment_expression_return non_assignment_expression1111 = default(csParser.non_assignment_expression_return);

		object char_literal1112_tree=null;

		try { DebugEnterRule(GrammarFileName, "non_assignment_expression_list");
		DebugLocation(1345, 34);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 316)) { return retval; }
			// cs.g:1345:38: ( ( non_assignment_expression ';' )+ )
			DebugEnterAlt(1);
			// cs.g:1346:2: ( non_assignment_expression ';' )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1346, 2);
			// cs.g:1346:2: ( non_assignment_expression ';' )+
			int cnt290=0;
			try { DebugEnterSubRule(290);
			while (true)
			{
				int alt290=2;
				try { DebugEnterDecision(290, decisionCanBacktrack[290]);
				int LA290_0 = input.LA(1);

				if (((LA290_0>=IDENTIFIER && LA290_0<=NULL)||LA290_0==MINUS||(LA290_0>=ELIF && LA290_0<=UNDEF)||LA290_0==65||LA290_0==68||(LA290_0>=83 && LA290_0<=84)||(LA290_0>=86 && LA290_0<=87)||LA290_0==90||(LA290_0>=95 && LA290_0<=100)||LA290_0==102||(LA290_0>=104 && LA290_0<=106)||LA290_0==117||(LA290_0>=132 && LA290_0<=133)||(LA290_0>=135 && LA290_0<=148)||(LA290_0>=150 && LA290_0<=152)||LA290_0==154||(LA290_0>=156 && LA290_0<=168)||LA290_0==170||(LA290_0>=177 && LA290_0<=178)||(LA290_0>=195 && LA290_0<=202)))
				{
					alt290=1;
				}


				} finally { DebugExitDecision(290); }
				switch (alt290)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1346:3: non_assignment_expression ';'
					{
					DebugLocation(1346, 3);
					PushFollow(Follow._non_assignment_expression_in_non_assignment_expression_list10983);
					non_assignment_expression1111=non_assignment_expression();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, non_assignment_expression1111.Tree);
					DebugLocation(1346, 29);
					char_literal1112=(IToken)Match(input,SEMI,Follow._SEMI_in_non_assignment_expression_list10985); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal1112_tree = (object)adaptor.Create(char_literal1112);
					adaptor.AddChild(root_0, char_literal1112_tree);
					}

					}
					break;

				default:
					if (cnt290 >= 1)
						goto loop290;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee290 = new EarlyExitException( 290, input );
					DebugRecognitionException(eee290);
					throw eee290;
				}
				cnt290++;
			}
			loop290:
				;

			} finally { DebugExitSubRule(290); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("non_assignment_expression_list", 316);
			LeaveRule("non_assignment_expression_list", 316);
			Leave_non_assignment_expression_list();
			if (state.backtracking > 0) { Memoize(input, 316, non_assignment_expression_list_StartIndex); }
		}
		DebugLocation(1346, 34);
		} finally { DebugExitRule(GrammarFileName, "non_assignment_expression_list"); }
		return retval;

	}
	// $ANTLR end "non_assignment_expression_list"

	public class method_declarations_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<object>
	{
		private object _tree;
		public object Tree { get { return _tree; } set { _tree = value; } }
	}

	partial void Enter_method_declarations();
	partial void Leave_method_declarations();

	// $ANTLR start "method_declarations"
	// cs.g:1347:8: public method_declarations : ( ( modifiers )? ( 'void' | type ) method_declaration )+ ;
	[GrammarRule("method_declarations")]
	public csParser.method_declarations_return method_declarations()
	{
		Enter_method_declarations();
		EnterRule("method_declarations", 317);
		TraceIn("method_declarations", 317);
		csParser.method_declarations_return retval = new csParser.method_declarations_return();
		retval.Start = (IToken)input.LT(1);
		int method_declarations_StartIndex = input.Index;
		object root_0 = null;

		IToken string_literal1114=null;
		csParser.modifiers_return modifiers1113 = default(csParser.modifiers_return);
		csParser.type_return type1115 = default(csParser.type_return);
		csParser.method_declaration_return method_declaration1116 = default(csParser.method_declaration_return);

		object string_literal1114_tree=null;

		try { DebugEnterRule(GrammarFileName, "method_declarations");
		DebugLocation(1347, 50);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 317)) { return retval; }
			// cs.g:1347:27: ( ( ( modifiers )? ( 'void' | type ) method_declaration )+ )
			DebugEnterAlt(1);
			// cs.g:1348:2: ( ( modifiers )? ( 'void' | type ) method_declaration )+
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(1348, 2);
			// cs.g:1348:2: ( ( modifiers )? ( 'void' | type ) method_declaration )+
			int cnt293=0;
			try { DebugEnterSubRule(293);
			while (true)
			{
				int alt293=2;
				try { DebugEnterDecision(293, decisionCanBacktrack[293]);
				int LA293_0 = input.LA(1);

				if ((LA293_0==IDENTIFIER||(LA293_0>=ELIF && LA293_0<=UNDEF)||(LA293_0>=64 && LA293_0<=65)||(LA293_0>=68 && LA293_0<=80)||LA293_0==82||(LA293_0>=132 && LA293_0<=133)||(LA293_0>=135 && LA293_0<=148)||(LA293_0>=150 && LA293_0<=152)||LA293_0==154||(LA293_0>=156 && LA293_0<=168)||LA293_0==170||(LA293_0>=177 && LA293_0<=178)||(LA293_0>=195 && LA293_0<=202)))
				{
					alt293=1;
				}


				} finally { DebugExitDecision(293); }
				switch (alt293)
				{
				case 1:
					DebugEnterAlt(1);
					// cs.g:1348:3: ( modifiers )? ( 'void' | type ) method_declaration
					{
					DebugLocation(1348, 3);
					// cs.g:1348:3: ( modifiers )?
					int alt291=2;
					try { DebugEnterSubRule(291);
					try { DebugEnterDecision(291, decisionCanBacktrack[291]);
					int LA291_0 = input.LA(1);

					if ((LA291_0==64||(LA291_0>=68 && LA291_0<=80)))
					{
						alt291=1;
					}
					} finally { DebugExitDecision(291); }
					switch (alt291)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:1348:3: modifiers
						{
						DebugLocation(1348, 3);
						PushFollow(Follow._modifiers_in_method_declarations10998);
						modifiers1113=modifiers();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers1113.Tree);

						}
						break;

					}
					} finally { DebugExitSubRule(291); }

					DebugLocation(1348, 14);
					// cs.g:1348:14: ( 'void' | type )
					int alt292=2;
					try { DebugEnterSubRule(292);
					try { DebugEnterDecision(292, decisionCanBacktrack[292]);
					int LA292_0 = input.LA(1);

					if ((LA292_0==82))
					{
						int LA292_1 = input.LA(2);

						if (((LA292_1>=IDENTIFIER && LA292_1<=NULL)||(LA292_1>=ELIF && LA292_1<=UNDEF)||LA292_1==65||(LA292_1>=132 && LA292_1<=133)||(LA292_1>=135 && LA292_1<=148)||(LA292_1>=150 && LA292_1<=152)||LA292_1==154||(LA292_1>=156 && LA292_1<=168)||LA292_1==170||(LA292_1>=177 && LA292_1<=178)||(LA292_1>=195 && LA292_1<=202)))
						{
							alt292=1;
						}
						else if ((LA292_1==102))
						{
							alt292=2;
						}
						else
						{
							if (state.backtracking>0) {state.failed=true; return retval;}
							NoViableAltException nvae = new NoViableAltException("", 292, 1, input);

							DebugRecognitionException(nvae);
							throw nvae;
						}
					}
					else if ((LA292_0==IDENTIFIER||(LA292_0>=ELIF && LA292_0<=UNDEF)||LA292_0==65||(LA292_0>=132 && LA292_0<=133)||(LA292_0>=135 && LA292_0<=148)||(LA292_0>=150 && LA292_0<=152)||LA292_0==154||(LA292_0>=156 && LA292_0<=168)||LA292_0==170||(LA292_0>=177 && LA292_0<=178)||(LA292_0>=195 && LA292_0<=202)))
					{
						alt292=2;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae = new NoViableAltException("", 292, 0, input);

						DebugRecognitionException(nvae);
						throw nvae;
					}
					} finally { DebugExitDecision(292); }
					switch (alt292)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:1348:15: 'void'
						{
						DebugLocation(1348, 15);
						string_literal1114=(IToken)Match(input,82,Follow._82_in_method_declarations11002); if (state.failed) return retval;
						if ( state.backtracking==0 ) {
						string_literal1114_tree = (object)adaptor.Create(string_literal1114);
						adaptor.AddChild(root_0, string_literal1114_tree);
						}

						}
						break;
					case 2:
						DebugEnterAlt(2);
						// cs.g:1348:24: type
						{
						DebugLocation(1348, 24);
						PushFollow(Follow._type_in_method_declarations11006);
						type1115=type();
						PopFollow();
						if (state.failed) return retval;
						if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type1115.Tree);

						}
						break;

					}
					} finally { DebugExitSubRule(292); }

					DebugLocation(1348, 30);
					PushFollow(Follow._method_declaration_in_method_declarations11009);
					method_declaration1116=method_declaration();
					PopFollow();
					if (state.failed) return retval;
					if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration1116.Tree);

					}
					break;

				default:
					if (cnt293 >= 1)
						goto loop293;

					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee293 = new EarlyExitException( 293, input );
					DebugRecognitionException(eee293);
					throw eee293;
				}
				cnt293++;
			}
			loop293:
				;

			} finally { DebugExitSubRule(293); }


			}

			retval.Stop = (IToken)input.LT(-1);

			if ( state.backtracking == 0 ) {

			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("method_declarations", 317);
			LeaveRule("method_declarations", 317);
			Leave_method_declarations();
			if (state.backtracking > 0) { Memoize(input, 317, method_declarations_StartIndex); }
		}
		DebugLocation(1348, 50);
		} finally { DebugExitRule(GrammarFileName, "method_declarations"); }
		return retval;

	}
	// $ANTLR end "method_declarations"

	partial void Enter_synpred1_cs_fragment();
	partial void Leave_synpred1_cs_fragment();

	// $ANTLR start synpred1_cs
	public void synpred1_cs_fragment()
	{
		Enter_synpred1_cs_fragment();
		EnterRule("synpred1_cs_fragment", 318);
		TraceIn("synpred1_cs_fragment", 318);
		try
		{
			// cs.g:60:2: ( 'partial' )
			DebugEnterAlt(1);
			// cs.g:60:3: 'partial'
			{
			DebugLocation(60, 3);
			Match(input,67,Follow._67_in_synpred1_cs291); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred1_cs_fragment", 318);
			LeaveRule("synpred1_cs_fragment", 318);
			Leave_synpred1_cs_fragment();
		}
	}
	// $ANTLR end synpred1_cs

	partial void Enter_synpred2_cs_fragment();
	partial void Leave_synpred2_cs_fragment();

	// $ANTLR start synpred2_cs
	public void synpred2_cs_fragment()
	{
		Enter_synpred2_cs_fragment();
		EnterRule("synpred2_cs_fragment", 319);
		TraceIn("synpred2_cs_fragment", 319);
		try
		{
			// cs.g:91:11: ( member_name '(' )
			DebugEnterAlt(1);
			// cs.g:91:12: member_name '('
			{
			DebugLocation(91, 12);
			PushFollow(Follow._member_name_in_synpred2_cs565);
			member_name();
			PopFollow();
			if (state.failed) return;
			DebugLocation(91, 26);
			Match(input,90,Follow._90_in_synpred2_cs569); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred2_cs_fragment", 319);
			LeaveRule("synpred2_cs_fragment", 319);
			Leave_synpred2_cs_fragment();
		}
	}
	// $ANTLR end synpred2_cs

	partial void Enter_synpred3_cs_fragment();
	partial void Leave_synpred3_cs_fragment();

	// $ANTLR start synpred3_cs
	public void synpred3_cs_fragment()
	{
		Enter_synpred3_cs_fragment();
		EnterRule("synpred3_cs_fragment", 320);
		TraceIn("synpred3_cs_fragment", 320);
		try
		{
			// cs.g:92:8: ( member_name '{' )
			DebugEnterAlt(1);
			// cs.g:92:9: member_name '{'
			{
			DebugLocation(92, 9);
			PushFollow(Follow._member_name_in_synpred3_cs584);
			member_name();
			PopFollow();
			if (state.failed) return;
			DebugLocation(92, 23);
			Match(input,62,Follow._62_in_synpred3_cs588); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred3_cs_fragment", 320);
			LeaveRule("synpred3_cs_fragment", 320);
			Leave_synpred3_cs_fragment();
		}
	}
	// $ANTLR end synpred3_cs

	partial void Enter_synpred4_cs_fragment();
	partial void Leave_synpred4_cs_fragment();

	// $ANTLR start synpred4_cs
	public void synpred4_cs_fragment()
	{
		Enter_synpred4_cs_fragment();
		EnterRule("synpred4_cs_fragment", 321);
		TraceIn("synpred4_cs_fragment", 321);
		try
		{
			// cs.g:93:8: ( member_name '.' 'this' )
			DebugEnterAlt(1);
			// cs.g:93:9: member_name '.' 'this'
			{
			DebugLocation(93, 9);
			PushFollow(Follow._member_name_in_synpred4_cs603);
			member_name();
			PopFollow();
			if (state.failed) return;
			DebugLocation(93, 23);
			Match(input,DOT,Follow._DOT_in_synpred4_cs607); if (state.failed) return;
			DebugLocation(93, 29);
			Match(input,83,Follow._83_in_synpred4_cs611); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred4_cs_fragment", 321);
			LeaveRule("synpred4_cs_fragment", 321);
			Leave_synpred4_cs_fragment();
		}
	}
	// $ANTLR end synpred4_cs

	partial void Enter_synpred5_cs_fragment();
	partial void Leave_synpred5_cs_fragment();

	// $ANTLR start synpred5_cs
	public void synpred5_cs_fragment()
	{
		Enter_synpred5_cs_fragment();
		EnterRule("synpred5_cs_fragment", 322);
		TraceIn("synpred5_cs_fragment", 322);
		try
		{
			// cs.g:111:2: ( 'this' brackets )
			DebugEnterAlt(1);
			// cs.g:111:3: 'this' brackets
			{
			DebugLocation(111, 3);
			Match(input,83,Follow._83_in_synpred5_cs733); if (state.failed) return;
			DebugLocation(111, 13);
			PushFollow(Follow._brackets_in_synpred5_cs738);
			brackets();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred5_cs_fragment", 322);
			LeaveRule("synpred5_cs_fragment", 322);
			Leave_synpred5_cs_fragment();
		}
	}
	// $ANTLR end synpred5_cs

	partial void Enter_synpred6_cs_fragment();
	partial void Leave_synpred6_cs_fragment();

	// $ANTLR start synpred6_cs
	public void synpred6_cs_fragment()
	{
		Enter_synpred6_cs_fragment();
		EnterRule("synpred6_cs_fragment", 323);
		TraceIn("synpred6_cs_fragment", 323);
		try
		{
			// cs.g:112:4: ( 'base' brackets )
			DebugEnterAlt(1);
			// cs.g:112:5: 'base' brackets
			{
			DebugLocation(112, 5);
			Match(input,84,Follow._84_in_synpred6_cs758); if (state.failed) return;
			DebugLocation(112, 14);
			PushFollow(Follow._brackets_in_synpred6_cs762);
			brackets();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred6_cs_fragment", 323);
			LeaveRule("synpred6_cs_fragment", 323);
			Leave_synpred6_cs_fragment();
		}
	}
	// $ANTLR end synpred6_cs

	partial void Enter_synpred7_cs_fragment();
	partial void Leave_synpred7_cs_fragment();

	// $ANTLR start synpred7_cs
	public void synpred7_cs_fragment()
	{
		Enter_synpred7_cs_fragment();
		EnterRule("synpred7_cs_fragment", 324);
		TraceIn("synpred7_cs_fragment", 324);
		try
		{
			// cs.g:114:14: ( object_creation_expression ( '.' | '->' | '[' ) )
			DebugEnterAlt(1);
			// cs.g:114:15: object_creation_expression ( '.' | '->' | '[' )
			{
			DebugLocation(114, 15);
			PushFollow(Follow._object_creation_expression_in_synpred7_cs798);
			object_creation_expression();
			PopFollow();
			if (state.failed) return;
			DebugLocation(114, 44);
			if ((input.LA(1)>=DOT && input.LA(1)<=PTR)||input.LA(1)==88)
			{
				input.Consume();
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

		}
		finally
		{
			TraceOut("synpred7_cs_fragment", 324);
			LeaveRule("synpred7_cs_fragment", 324);
			Leave_synpred7_cs_fragment();
		}
	}
	// $ANTLR end synpred7_cs

	partial void Enter_synpred8_cs_fragment();
	partial void Leave_synpred8_cs_fragment();

	// $ANTLR start synpred8_cs
	public void synpred8_cs_fragment()
	{
		Enter_synpred8_cs_fragment();
		EnterRule("synpred8_cs_fragment", 325);
		TraceIn("synpred8_cs_fragment", 325);
		try
		{
			// cs.g:118:7: ( delegate_creation_expression )
			DebugEnterAlt(1);
			// cs.g:118:8: delegate_creation_expression
			{
			DebugLocation(118, 8);
			PushFollow(Follow._delegate_creation_expression_in_synpred8_cs846);
			delegate_creation_expression();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred8_cs_fragment", 325);
			LeaveRule("synpred8_cs_fragment", 325);
			Leave_synpred8_cs_fragment();
		}
	}
	// $ANTLR end synpred8_cs

	partial void Enter_synpred9_cs_fragment();
	partial void Leave_synpred9_cs_fragment();

	// $ANTLR start synpred9_cs
	public void synpred9_cs_fragment()
	{
		Enter_synpred9_cs_fragment();
		EnterRule("synpred9_cs_fragment", 326);
		TraceIn("synpred9_cs_fragment", 326);
		try
		{
			// cs.g:130:4: ( identifier generic_argument_list )
			DebugEnterAlt(1);
			// cs.g:130:5: identifier generic_argument_list
			{
			DebugLocation(130, 5);
			PushFollow(Follow._identifier_in_synpred9_cs973);
			identifier();
			PopFollow();
			if (state.failed) return;
			DebugLocation(130, 19);
			PushFollow(Follow._generic_argument_list_in_synpred9_cs978);
			generic_argument_list();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred9_cs_fragment", 326);
			LeaveRule("synpred9_cs_fragment", 326);
			Leave_synpred9_cs_fragment();
		}
	}
	// $ANTLR end synpred9_cs

	partial void Enter_synpred10_cs_fragment();
	partial void Leave_synpred10_cs_fragment();

	// $ANTLR start synpred10_cs
	public void synpred10_cs_fragment()
	{
		Enter_synpred10_cs_fragment();
		EnterRule("synpred10_cs_fragment", 327);
		TraceIn("synpred10_cs_fragment", 327);
		try
		{
			// cs.g:170:4: ( '(' type ')' )
			DebugEnterAlt(1);
			// cs.g:170:5: '(' type ')'
			{
			DebugLocation(170, 5);
			Match(input,90,Follow._90_in_synpred10_cs1265); if (state.failed) return;
			DebugLocation(170, 11);
			PushFollow(Follow._type_in_synpred10_cs1269);
			type();
			PopFollow();
			if (state.failed) return;
			DebugLocation(170, 18);
			Match(input,RPAREN,Follow._RPAREN_in_synpred10_cs1273); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred10_cs_fragment", 327);
			LeaveRule("synpred10_cs_fragment", 327);
			Leave_synpred10_cs_fragment();
		}
	}
	// $ANTLR end synpred10_cs

	partial void Enter_synpred11_cs_fragment();
	partial void Leave_synpred11_cs_fragment();

	// $ANTLR start synpred11_cs
	public void synpred11_cs_fragment()
	{
		Enter_synpred11_cs_fragment();
		EnterRule("synpred11_cs_fragment", 328);
		TraceIn("synpred11_cs_fragment", 328);
		try
		{
			// cs.g:196:2: ( array_creation_expression )
			DebugEnterAlt(1);
			// cs.g:196:3: array_creation_expression
			{
			DebugLocation(196, 3);
			PushFollow(Follow._array_creation_expression_in_synpred11_cs1514);
			array_creation_expression();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred11_cs_fragment", 328);
			LeaveRule("synpred11_cs_fragment", 328);
			Leave_synpred11_cs_fragment();
		}
	}
	// $ANTLR end synpred11_cs

	partial void Enter_synpred12_cs_fragment();
	partial void Leave_synpred12_cs_fragment();

	// $ANTLR start synpred12_cs
	public void synpred12_cs_fragment()
	{
		Enter_synpred12_cs_fragment();
		EnterRule("synpred12_cs_fragment", 329);
		TraceIn("synpred12_cs_fragment", 329);
		try
		{
			// cs.g:205:11: ( arguments ( '[' | '.' | '->' ) )
			DebugEnterAlt(1);
			// cs.g:205:12: arguments ( '[' | '.' | '->' )
			{
			DebugLocation(205, 12);
			PushFollow(Follow._arguments_in_synpred12_cs1596);
			arguments();
			PopFollow();
			if (state.failed) return;
			DebugLocation(205, 24);
			if ((input.LA(1)>=DOT && input.LA(1)<=PTR)||input.LA(1)==88)
			{
				input.Consume();
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

		}
		finally
		{
			TraceOut("synpred12_cs_fragment", 329);
			LeaveRule("synpred12_cs_fragment", 329);
			Leave_synpred12_cs_fragment();
		}
	}
	// $ANTLR end synpred12_cs

	partial void Enter_synpred13_cs_fragment();
	partial void Leave_synpred13_cs_fragment();

	// $ANTLR start synpred13_cs
	public void synpred13_cs_fragment()
	{
		Enter_synpred13_cs_fragment();
		EnterRule("synpred13_cs_fragment", 330);
		TraceIn("synpred13_cs_fragment", 330);
		try
		{
			// cs.g:276:20: ( unbound_type_name )
			DebugEnterAlt(1);
			// cs.g:276:21: unbound_type_name
			{
			DebugLocation(276, 21);
			PushFollow(Follow._unbound_type_name_in_synpred13_cs2170);
			unbound_type_name();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred13_cs_fragment", 330);
			LeaveRule("synpred13_cs_fragment", 330);
			Leave_synpred13_cs_fragment();
		}
	}
	// $ANTLR end synpred13_cs

	partial void Enter_synpred14_cs_fragment();
	partial void Leave_synpred14_cs_fragment();

	// $ANTLR start synpred14_cs
	public void synpred14_cs_fragment()
	{
		Enter_synpred14_cs_fragment();
		EnterRule("synpred14_cs_fragment", 331);
		TraceIn("synpred14_cs_fragment", 331);
		try
		{
			// cs.g:286:5: ( generic_dimension_specifier '.' )
			DebugEnterAlt(1);
			// cs.g:286:6: generic_dimension_specifier '.'
			{
			DebugLocation(286, 6);
			PushFollow(Follow._generic_dimension_specifier_in_synpred14_cs2230);
			generic_dimension_specifier();
			PopFollow();
			if (state.failed) return;
			DebugLocation(286, 36);
			Match(input,DOT,Follow._DOT_in_synpred14_cs2234); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred14_cs_fragment", 331);
			LeaveRule("synpred14_cs_fragment", 331);
			Leave_synpred14_cs_fragment();
		}
	}
	// $ANTLR end synpred14_cs

	partial void Enter_synpred15_cs_fragment();
	partial void Leave_synpred15_cs_fragment();

	// $ANTLR start synpred15_cs
	public void synpred15_cs_fragment()
	{
		Enter_synpred15_cs_fragment();
		EnterRule("synpred15_cs_fragment", 332);
		TraceIn("synpred15_cs_fragment", 332);
		try
		{
			// cs.g:309:2: ( identifier generic_argument_list )
			DebugEnterAlt(1);
			// cs.g:309:3: identifier generic_argument_list
			{
			DebugLocation(309, 3);
			PushFollow(Follow._identifier_in_synpred15_cs2380);
			identifier();
			PopFollow();
			if (state.failed) return;
			DebugLocation(309, 16);
			PushFollow(Follow._generic_argument_list_in_synpred15_cs2384);
			generic_argument_list();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred15_cs_fragment", 332);
			LeaveRule("synpred15_cs_fragment", 332);
			Leave_synpred15_cs_fragment();
		}
	}
	// $ANTLR end synpred15_cs

	partial void Enter_synpred16_cs_fragment();
	partial void Leave_synpred16_cs_fragment();

	// $ANTLR start synpred16_cs
	public void synpred16_cs_fragment()
	{
		Enter_synpred16_cs_fragment();
		EnterRule("synpred16_cs_fragment", 333);
		TraceIn("synpred16_cs_fragment", 333);
		try
		{
			// cs.g:317:4: ( identifier generic_argument_list )
			DebugEnterAlt(1);
			// cs.g:317:5: identifier generic_argument_list
			{
			DebugLocation(317, 5);
			PushFollow(Follow._identifier_in_synpred16_cs2433);
			identifier();
			PopFollow();
			if (state.failed) return;
			DebugLocation(317, 18);
			PushFollow(Follow._generic_argument_list_in_synpred16_cs2437);
			generic_argument_list();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred16_cs_fragment", 333);
			LeaveRule("synpred16_cs_fragment", 333);
			Leave_synpred16_cs_fragment();
		}
	}
	// $ANTLR end synpred16_cs

	partial void Enter_synpred17_cs_fragment();
	partial void Leave_synpred17_cs_fragment();

	// $ANTLR start synpred17_cs
	public void synpred17_cs_fragment()
	{
		Enter_synpred17_cs_fragment();
		EnterRule("synpred17_cs_fragment", 334);
		TraceIn("synpred17_cs_fragment", 334);
		try
		{
			// cs.g:334:4: ( ( predefined_type | type_name ) rank_specifiers )
			DebugEnterAlt(1);
			// cs.g:334:5: ( predefined_type | type_name ) rank_specifiers
			{
			DebugLocation(334, 5);
			// cs.g:334:5: ( predefined_type | type_name )
			int alt294=2;
			try { DebugEnterSubRule(294);
			try { DebugEnterDecision(294, decisionCanBacktrack[294]);
			int LA294_0 = input.LA(1);

			if (((LA294_0>=160 && LA294_0<=168)||(LA294_0>=196 && LA294_0<=201)))
			{
				alt294=1;
			}
			else if ((LA294_0==IDENTIFIER||(LA294_0>=ELIF && LA294_0<=UNDEF)||LA294_0==65||(LA294_0>=132 && LA294_0<=133)||(LA294_0>=135 && LA294_0<=148)||(LA294_0>=150 && LA294_0<=152)||LA294_0==154||(LA294_0>=156 && LA294_0<=159)||LA294_0==170||(LA294_0>=177 && LA294_0<=178)||LA294_0==195||LA294_0==202))
			{
				alt294=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				NoViableAltException nvae = new NoViableAltException("", 294, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(294); }
			switch (alt294)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:334:6: predefined_type
				{
				DebugLocation(334, 6);
				PushFollow(Follow._predefined_type_in_synpred17_cs2538);
				predefined_type();
				PopFollow();
				if (state.failed) return;

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:334:24: type_name
				{
				DebugLocation(334, 24);
				PushFollow(Follow._type_name_in_synpred17_cs2542);
				type_name();
				PopFollow();
				if (state.failed) return;

				}
				break;

			}
			} finally { DebugExitSubRule(294); }

			DebugLocation(334, 36);
			PushFollow(Follow._rank_specifiers_in_synpred17_cs2546);
			rank_specifiers();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred17_cs_fragment", 334);
			LeaveRule("synpred17_cs_fragment", 334);
			Leave_synpred17_cs_fragment();
		}
	}
	// $ANTLR end synpred17_cs

	partial void Enter_synpred18_cs_fragment();
	partial void Leave_synpred18_cs_fragment();

	// $ANTLR start synpred18_cs
	public void synpred18_cs_fragment()
	{
		Enter_synpred18_cs_fragment();
		EnterRule("synpred18_cs_fragment", 335);
		TraceIn("synpred18_cs_fragment", 335);
		try
		{
			// cs.g:335:4: ( ( predefined_type | type_name ) ( ( '*' )+ | '?' ) )
			DebugEnterAlt(1);
			// cs.g:335:5: ( predefined_type | type_name ) ( ( '*' )+ | '?' )
			{
			DebugLocation(335, 5);
			// cs.g:335:5: ( predefined_type | type_name )
			int alt295=2;
			try { DebugEnterSubRule(295);
			try { DebugEnterDecision(295, decisionCanBacktrack[295]);
			int LA295_0 = input.LA(1);

			if (((LA295_0>=160 && LA295_0<=168)||(LA295_0>=196 && LA295_0<=201)))
			{
				alt295=1;
			}
			else if ((LA295_0==IDENTIFIER||(LA295_0>=ELIF && LA295_0<=UNDEF)||LA295_0==65||(LA295_0>=132 && LA295_0<=133)||(LA295_0>=135 && LA295_0<=148)||(LA295_0>=150 && LA295_0<=152)||LA295_0==154||(LA295_0>=156 && LA295_0<=159)||LA295_0==170||(LA295_0>=177 && LA295_0<=178)||LA295_0==195||LA295_0==202))
			{
				alt295=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				NoViableAltException nvae = new NoViableAltException("", 295, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(295); }
			switch (alt295)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:335:6: predefined_type
				{
				DebugLocation(335, 6);
				PushFollow(Follow._predefined_type_in_synpred18_cs2573);
				predefined_type();
				PopFollow();
				if (state.failed) return;

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:335:24: type_name
				{
				DebugLocation(335, 24);
				PushFollow(Follow._type_name_in_synpred18_cs2577);
				type_name();
				PopFollow();
				if (state.failed) return;

				}
				break;

			}
			} finally { DebugExitSubRule(295); }

			DebugLocation(335, 36);
			// cs.g:335:36: ( ( '*' )+ | '?' )
			int alt297=2;
			try { DebugEnterSubRule(297);
			try { DebugEnterDecision(297, decisionCanBacktrack[297]);
			int LA297_0 = input.LA(1);

			if ((LA297_0==102))
			{
				alt297=1;
			}
			else if ((LA297_0==103))
			{
				alt297=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				NoViableAltException nvae = new NoViableAltException("", 297, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(297); }
			switch (alt297)
			{
			case 1:
				DebugEnterAlt(1);
				// cs.g:335:37: ( '*' )+
				{
				DebugLocation(335, 37);
				// cs.g:335:37: ( '*' )+
				int cnt296=0;
				try { DebugEnterSubRule(296);
				while (true)
				{
					int alt296=2;
					try { DebugEnterDecision(296, decisionCanBacktrack[296]);
					int LA296_0 = input.LA(1);

					if ((LA296_0==102))
					{
						alt296=1;
					}


					} finally { DebugExitDecision(296); }
					switch (alt296)
					{
					case 1:
						DebugEnterAlt(1);
						// cs.g:335:37: '*'
						{
						DebugLocation(335, 37);
						Match(input,102,Follow._102_in_synpred18_cs2582); if (state.failed) return;

						}
						break;

					default:
						if (cnt296 >= 1)
							goto loop296;

						if (state.backtracking>0) {state.failed=true; return;}
						EarlyExitException eee296 = new EarlyExitException( 296, input );
						DebugRecognitionException(eee296);
						throw eee296;
					}
					cnt296++;
				}
				loop296:
					;

				} finally { DebugExitSubRule(296); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// cs.g:335:44: '?'
				{
				DebugLocation(335, 44);
				Match(input,103,Follow._103_in_synpred18_cs2587); if (state.failed) return;

				}
				break;

			}
			} finally { DebugExitSubRule(297); }


			}

		}
		finally
		{
			TraceOut("synpred18_cs_fragment", 335);
			LeaveRule("synpred18_cs_fragment", 335);
			Leave_synpred18_cs_fragment();
		}
	}
	// $ANTLR end synpred18_cs

	partial void Enter_synpred19_cs_fragment();
	partial void Leave_synpred19_cs_fragment();

	// $ANTLR start synpred19_cs
	public void synpred19_cs_fragment()
	{
		Enter_synpred19_cs_fragment();
		EnterRule("synpred19_cs_fragment", 336);
		TraceIn("synpred19_cs_fragment", 336);
		try
		{
			// cs.g:371:2: ( unary_expression assignment_operator )
			DebugEnterAlt(1);
			// cs.g:371:3: unary_expression assignment_operator
			{
			DebugLocation(371, 3);
			PushFollow(Follow._unary_expression_in_synpred19_cs2787);
			unary_expression();
			PopFollow();
			if (state.failed) return;
			DebugLocation(371, 22);
			PushFollow(Follow._assignment_operator_in_synpred19_cs2791);
			assignment_operator();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred19_cs_fragment", 336);
			LeaveRule("synpred19_cs_fragment", 336);
			Leave_synpred19_cs_fragment();
		}
	}
	// $ANTLR end synpred19_cs

	partial void Enter_synpred20_cs_fragment();
	partial void Leave_synpred20_cs_fragment();

	// $ANTLR start synpred20_cs
	public void synpred20_cs_fragment()
	{
		Enter_synpred20_cs_fragment();
		EnterRule("synpred20_cs_fragment", 337);
		TraceIn("synpred20_cs_fragment", 337);
		try
		{
			// cs.g:380:2: ( cast_expression )
			DebugEnterAlt(1);
			// cs.g:380:3: cast_expression
			{
			DebugLocation(380, 3);
			PushFollow(Follow._cast_expression_in_synpred20_cs2855);
			cast_expression();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred20_cs_fragment", 337);
			LeaveRule("synpred20_cs_fragment", 337);
			Leave_synpred20_cs_fragment();
		}
	}
	// $ANTLR end synpred20_cs

	partial void Enter_synpred21_cs_fragment();
	partial void Leave_synpred21_cs_fragment();

	// $ANTLR start synpred21_cs
	public void synpred21_cs_fragment()
	{
		Enter_synpred21_cs_fragment();
		EnterRule("synpred21_cs_fragment", 338);
		TraceIn("synpred21_cs_fragment", 338);
		try
		{
			// cs.g:406:2: ( anonymous_function_signature '=>' )
			DebugEnterAlt(1);
			// cs.g:406:3: anonymous_function_signature '=>'
			{
			DebugLocation(406, 3);
			PushFollow(Follow._anonymous_function_signature_in_synpred21_cs3075);
			anonymous_function_signature();
			PopFollow();
			if (state.failed) return;
			DebugLocation(406, 34);
			Match(input,131,Follow._131_in_synpred21_cs3079); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred21_cs_fragment", 338);
			LeaveRule("synpred21_cs_fragment", 338);
			Leave_synpred21_cs_fragment();
		}
	}
	// $ANTLR end synpred21_cs

	partial void Enter_synpred22_cs_fragment();
	partial void Leave_synpred22_cs_fragment();

	// $ANTLR start synpred22_cs
	public void synpred22_cs_fragment()
	{
		Enter_synpred22_cs_fragment();
		EnterRule("synpred22_cs_fragment", 339);
		TraceIn("synpred22_cs_fragment", 339);
		try
		{
			// cs.g:407:4: ( query_expression )
			DebugEnterAlt(1);
			// cs.g:407:5: query_expression
			{
			DebugLocation(407, 5);
			PushFollow(Follow._query_expression_in_synpred22_cs3090);
			query_expression();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred22_cs_fragment", 339);
			LeaveRule("synpred22_cs_fragment", 339);
			Leave_synpred22_cs_fragment();
		}
	}
	// $ANTLR end synpred22_cs

	partial void Enter_synpred23_cs_fragment();
	partial void Leave_synpred23_cs_fragment();

	// $ANTLR start synpred23_cs
	public void synpred23_cs_fragment()
	{
		Enter_synpred23_cs_fragment();
		EnterRule("synpred23_cs_fragment", 340);
		TraceIn("synpred23_cs_fragment", 340);
		try
		{
			// cs.g:471:50: ( 'into' )
			DebugEnterAlt(1);
			// cs.g:471:51: 'into'
			{
			DebugLocation(471, 51);
			Match(input,132,Follow._132_in_synpred23_cs3551); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred23_cs_fragment", 340);
			LeaveRule("synpred23_cs_fragment", 340);
			Leave_synpred23_cs_fragment();
		}
	}
	// $ANTLR end synpred23_cs

	partial void Enter_synpred24_cs_fragment();
	partial void Leave_synpred24_cs_fragment();

	// $ANTLR start synpred24_cs
	public void synpred24_cs_fragment()
	{
		Enter_synpred24_cs_fragment();
		EnterRule("synpred24_cs_fragment", 341);
		TraceIn("synpred24_cs_fragment", 341);
		try
		{
			// cs.g:538:32: ( ',' identifier '=' )
			DebugEnterAlt(1);
			// cs.g:538:33: ',' identifier '='
			{
			DebugLocation(538, 33);
			Match(input,91,Follow._91_in_synpred24_cs4107); if (state.failed) return;
			DebugLocation(538, 39);
			PushFollow(Follow._identifier_in_synpred24_cs4111);
			identifier();
			PopFollow();
			if (state.failed) return;
			DebugLocation(538, 52);
			Match(input,66,Follow._66_in_synpred24_cs4115); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred24_cs_fragment", 341);
			LeaveRule("synpred24_cs_fragment", 341);
			Leave_synpred24_cs_fragment();
		}
	}
	// $ANTLR end synpred24_cs

	partial void Enter_synpred25_cs_fragment();
	partial void Leave_synpred25_cs_fragment();

	// $ANTLR start synpred25_cs
	public void synpred25_cs_fragment()
	{
		Enter_synpred25_cs_fragment();
		EnterRule("synpred25_cs_fragment", 342);
		TraceIn("synpred25_cs_fragment", 342);
		try
		{
			// cs.g:619:4: ( member_name '{' )
			DebugEnterAlt(1);
			// cs.g:619:5: member_name '{'
			{
			DebugLocation(619, 5);
			PushFollow(Follow._member_name_in_synpred25_cs4689);
			member_name();
			PopFollow();
			if (state.failed) return;
			DebugLocation(619, 19);
			Match(input,62,Follow._62_in_synpred25_cs4693); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred25_cs_fragment", 342);
			LeaveRule("synpred25_cs_fragment", 342);
			Leave_synpred25_cs_fragment();
		}
	}
	// $ANTLR end synpred25_cs

	partial void Enter_synpred26_cs_fragment();
	partial void Leave_synpred26_cs_fragment();

	// $ANTLR start synpred26_cs
	public void synpred26_cs_fragment()
	{
		Enter_synpred26_cs_fragment();
		EnterRule("synpred26_cs_fragment", 343);
		TraceIn("synpred26_cs_fragment", 343);
		try
		{
			// cs.g:726:14: ( member_name '(' )
			DebugEnterAlt(1);
			// cs.g:726:15: member_name '('
			{
			DebugLocation(726, 15);
			PushFollow(Follow._member_name_in_synpred26_cs5628);
			member_name();
			PopFollow();
			if (state.failed) return;
			DebugLocation(726, 29);
			Match(input,90,Follow._90_in_synpred26_cs5632); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred26_cs_fragment", 343);
			LeaveRule("synpred26_cs_fragment", 343);
			Leave_synpred26_cs_fragment();
		}
	}
	// $ANTLR end synpred26_cs

	partial void Enter_synpred27_cs_fragment();
	partial void Leave_synpred27_cs_fragment();

	// $ANTLR start synpred27_cs
	public void synpred27_cs_fragment()
	{
		Enter_synpred27_cs_fragment();
		EnterRule("synpred27_cs_fragment", 344);
		TraceIn("synpred27_cs_fragment", 344);
		try
		{
			// cs.g:727:14: ( member_name '{' )
			DebugEnterAlt(1);
			// cs.g:727:15: member_name '{'
			{
			DebugLocation(727, 15);
			PushFollow(Follow._member_name_in_synpred27_cs5653);
			member_name();
			PopFollow();
			if (state.failed) return;
			DebugLocation(727, 29);
			Match(input,62,Follow._62_in_synpred27_cs5657); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred27_cs_fragment", 344);
			LeaveRule("synpred27_cs_fragment", 344);
			Leave_synpred27_cs_fragment();
		}
	}
	// $ANTLR end synpred27_cs

	partial void Enter_synpred28_cs_fragment();
	partial void Leave_synpred28_cs_fragment();

	// $ANTLR start synpred28_cs
	public void synpred28_cs_fragment()
	{
		Enter_synpred28_cs_fragment();
		EnterRule("synpred28_cs_fragment", 345);
		TraceIn("synpred28_cs_fragment", 345);
		try
		{
			// cs.g:778:11: ( member_name '(' )
			DebugEnterAlt(1);
			// cs.g:778:12: member_name '('
			{
			DebugLocation(778, 12);
			PushFollow(Follow._member_name_in_synpred28_cs6131);
			member_name();
			PopFollow();
			if (state.failed) return;
			DebugLocation(778, 26);
			Match(input,90,Follow._90_in_synpred28_cs6135); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred28_cs_fragment", 345);
			LeaveRule("synpred28_cs_fragment", 345);
			Leave_synpred28_cs_fragment();
		}
	}
	// $ANTLR end synpred28_cs

	partial void Enter_synpred29_cs_fragment();
	partial void Leave_synpred29_cs_fragment();

	// $ANTLR start synpred29_cs
	public void synpred29_cs_fragment()
	{
		Enter_synpred29_cs_fragment();
		EnterRule("synpred29_cs_fragment", 346);
		TraceIn("synpred29_cs_fragment", 346);
		try
		{
			// cs.g:779:8: ( member_name '{' )
			DebugEnterAlt(1);
			// cs.g:779:9: member_name '{'
			{
			DebugLocation(779, 9);
			PushFollow(Follow._member_name_in_synpred29_cs6150);
			member_name();
			PopFollow();
			if (state.failed) return;
			DebugLocation(779, 23);
			Match(input,62,Follow._62_in_synpred29_cs6154); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred29_cs_fragment", 346);
			LeaveRule("synpred29_cs_fragment", 346);
			Leave_synpred29_cs_fragment();
		}
	}
	// $ANTLR end synpred29_cs

	partial void Enter_synpred30_cs_fragment();
	partial void Leave_synpred30_cs_fragment();

	// $ANTLR start synpred30_cs
	public void synpred30_cs_fragment()
	{
		Enter_synpred30_cs_fragment();
		EnterRule("synpred30_cs_fragment", 347);
		TraceIn("synpred30_cs_fragment", 347);
		try
		{
			// cs.g:780:8: ( member_name '.' 'this' )
			DebugEnterAlt(1);
			// cs.g:780:9: member_name '.' 'this'
			{
			DebugLocation(780, 9);
			PushFollow(Follow._member_name_in_synpred30_cs6169);
			member_name();
			PopFollow();
			if (state.failed) return;
			DebugLocation(780, 23);
			Match(input,DOT,Follow._DOT_in_synpred30_cs6173); if (state.failed) return;
			DebugLocation(780, 29);
			Match(input,83,Follow._83_in_synpred30_cs6177); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred30_cs_fragment", 347);
			LeaveRule("synpred30_cs_fragment", 347);
			Leave_synpred30_cs_fragment();
		}
	}
	// $ANTLR end synpred30_cs

	partial void Enter_synpred31_cs_fragment();
	partial void Leave_synpred31_cs_fragment();

	// $ANTLR start synpred31_cs
	public void synpred31_cs_fragment()
	{
		Enter_synpred31_cs_fragment();
		EnterRule("synpred31_cs_fragment", 348);
		TraceIn("synpred31_cs_fragment", 348);
		try
		{
			// cs.g:852:23: ( arguments ( '[' | '.' | '->' ) )
			DebugEnterAlt(1);
			// cs.g:852:24: arguments ( '[' | '.' | '->' )
			{
			DebugLocation(852, 24);
			PushFollow(Follow._arguments_in_synpred31_cs6778);
			arguments();
			PopFollow();
			if (state.failed) return;
			DebugLocation(852, 36);
			if ((input.LA(1)>=DOT && input.LA(1)<=PTR)||input.LA(1)==88)
			{
				input.Consume();
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

		}
		finally
		{
			TraceOut("synpred31_cs_fragment", 348);
			LeaveRule("synpred31_cs_fragment", 348);
			Leave_synpred31_cs_fragment();
		}
	}
	// $ANTLR end synpred31_cs

	partial void Enter_synpred32_cs_fragment();
	partial void Leave_synpred32_cs_fragment();

	// $ANTLR start synpred32_cs
	public void synpred32_cs_fragment()
	{
		Enter_synpred32_cs_fragment();
		EnterRule("synpred32_cs_fragment", 349);
		TraceIn("synpred32_cs_fragment", 349);
		try
		{
			// cs.g:856:4: ( identifier generic_argument_list )
			DebugEnterAlt(1);
			// cs.g:856:5: identifier generic_argument_list
			{
			DebugLocation(856, 5);
			PushFollow(Follow._identifier_in_synpred32_cs6831);
			identifier();
			PopFollow();
			if (state.failed) return;
			DebugLocation(856, 19);
			PushFollow(Follow._generic_argument_list_in_synpred32_cs6836);
			generic_argument_list();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred32_cs_fragment", 349);
			LeaveRule("synpred32_cs_fragment", 349);
			Leave_synpred32_cs_fragment();
		}
	}
	// $ANTLR end synpred32_cs

	partial void Enter_synpred33_cs_fragment();
	partial void Leave_synpred33_cs_fragment();

	// $ANTLR start synpred33_cs
	public void synpred33_cs_fragment()
	{
		Enter_synpred33_cs_fragment();
		EnterRule("synpred33_cs_fragment", 350);
		TraceIn("synpred33_cs_fragment", 350);
		try
		{
			// cs.g:869:2: ( declaration_statement )
			DebugEnterAlt(1);
			// cs.g:869:3: declaration_statement
			{
			DebugLocation(869, 3);
			PushFollow(Follow._declaration_statement_in_synpred33_cs6921);
			declaration_statement();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred33_cs_fragment", 350);
			LeaveRule("synpred33_cs_fragment", 350);
			Leave_synpred33_cs_fragment();
		}
	}
	// $ANTLR end synpred33_cs

	partial void Enter_synpred34_cs_fragment();
	partial void Leave_synpred34_cs_fragment();

	// $ANTLR start synpred34_cs
	public void synpred34_cs_fragment()
	{
		Enter_synpred34_cs_fragment();
		EnterRule("synpred34_cs_fragment", 351);
		TraceIn("synpred34_cs_fragment", 351);
		try
		{
			// cs.g:870:4: ( identifier ':' )
			DebugEnterAlt(1);
			// cs.g:870:5: identifier ':'
			{
			DebugLocation(870, 5);
			PushFollow(Follow._identifier_in_synpred34_cs6932);
			identifier();
			PopFollow();
			if (state.failed) return;
			DebugLocation(870, 18);
			Match(input,92,Follow._92_in_synpred34_cs6936); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred34_cs_fragment", 351);
			LeaveRule("synpred34_cs_fragment", 351);
			Leave_synpred34_cs_fragment();
		}
	}
	// $ANTLR end synpred34_cs

	partial void Enter_synpred35_cs_fragment();
	partial void Leave_synpred35_cs_fragment();

	// $ANTLR start synpred35_cs
	public void synpred35_cs_fragment()
	{
		Enter_synpred35_cs_fragment();
		EnterRule("synpred35_cs_fragment", 352);
		TraceIn("synpred35_cs_fragment", 352);
		try
		{
			// cs.g:907:2: ( 'var' )
			DebugEnterAlt(1);
			// cs.g:907:3: 'var'
			{
			DebugLocation(907, 3);
			Match(input,177,Follow._177_in_synpred35_cs7180); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred35_cs_fragment", 352);
			LeaveRule("synpred35_cs_fragment", 352);
			Leave_synpred35_cs_fragment();
		}
	}
	// $ANTLR end synpred35_cs

	partial void Enter_synpred36_cs_fragment();
	partial void Leave_synpred36_cs_fragment();

	// $ANTLR start synpred36_cs
	public void synpred36_cs_fragment()
	{
		Enter_synpred36_cs_fragment();
		EnterRule("synpred36_cs_fragment", 353);
		TraceIn("synpred36_cs_fragment", 353);
		try
		{
			// cs.g:908:4: ( 'dynamic' )
			DebugEnterAlt(1);
			// cs.g:908:5: 'dynamic'
			{
			DebugLocation(908, 5);
			Match(input,178,Follow._178_in_synpred36_cs7191); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred36_cs_fragment", 353);
			LeaveRule("synpred36_cs_fragment", 353);
			Leave_synpred36_cs_fragment();
		}
	}
	// $ANTLR end synpred36_cs

	partial void Enter_synpred37_cs_fragment();
	partial void Leave_synpred37_cs_fragment();

	// $ANTLR start synpred37_cs
	public void synpred37_cs_fragment()
	{
		Enter_synpred37_cs_fragment();
		EnterRule("synpred37_cs_fragment", 354);
		TraceIn("synpred37_cs_fragment", 354);
		try
		{
			// cs.g:934:62: ( 'else' )
			DebugEnterAlt(1);
			// cs.g:934:63: 'else'
			{
			DebugLocation(934, 63);
			Match(input,180,Follow._180_in_synpred37_cs7376); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred37_cs_fragment", 354);
			LeaveRule("synpred37_cs_fragment", 354);
			Leave_synpred37_cs_fragment();
		}
	}
	// $ANTLR end synpred37_cs

	partial void Enter_synpred38_cs_fragment();
	partial void Leave_synpred38_cs_fragment();

	// $ANTLR start synpred38_cs
	public void synpred38_cs_fragment()
	{
		Enter_synpred38_cs_fragment();
		EnterRule("synpred38_cs_fragment", 355);
		TraceIn("synpred38_cs_fragment", 355);
		try
		{
			// cs.g:963:2: ( local_variable_declaration )
			DebugEnterAlt(1);
			// cs.g:963:3: local_variable_declaration
			{
			DebugLocation(963, 3);
			PushFollow(Follow._local_variable_declaration_in_synpred38_cs7651);
			local_variable_declaration();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred38_cs_fragment", 355);
			LeaveRule("synpred38_cs_fragment", 355);
			Leave_synpred38_cs_fragment();
		}
	}
	// $ANTLR end synpred38_cs

	partial void Enter_synpred39_cs_fragment();
	partial void Leave_synpred39_cs_fragment();

	// $ANTLR start synpred39_cs
	public void synpred39_cs_fragment()
	{
		Enter_synpred39_cs_fragment();
		EnterRule("synpred39_cs_fragment", 356);
		TraceIn("synpred39_cs_fragment", 356);
		try
		{
			// cs.g:1015:2: ( local_variable_declaration )
			DebugEnterAlt(1);
			// cs.g:1015:3: local_variable_declaration
			{
			DebugLocation(1015, 3);
			PushFollow(Follow._local_variable_declaration_in_synpred39_cs8106);
			local_variable_declaration();
			PopFollow();
			if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("synpred39_cs_fragment", 356);
			LeaveRule("synpred39_cs_fragment", 356);
			Leave_synpred39_cs_fragment();
		}
	}
	// $ANTLR end synpred39_cs
	#endregion Rules

	#region Synpreds
	private bool EvaluatePredicate(System.Action fragment)
	{
		bool success = false;
		state.backtracking++;
		try { DebugBeginBacktrack(state.backtracking);
		int start = input.Mark();
		try
		{
			fragment();
		}
		catch ( RecognitionException re )
		{
			System.Console.Error.WriteLine("impossible: "+re);
		}
		success = !state.failed;
		input.Rewind(start);
		} finally { DebugEndBacktrack(state.backtracking, success); }
		state.backtracking--;
		state.failed=false;
		return success;
	}
	#endregion Synpreds


	#region DFA
	DFA21 dfa21;
	DFA20 dfa20;
	DFA27 dfa27;
	DFA29 dfa29;
	DFA38 dfa38;
	DFA46 dfa46;
	DFA50 dfa50;
	DFA71 dfa71;
	DFA72 dfa72;
	DFA101 dfa101;
	DFA103 dfa103;
	DFA104 dfa104;
	DFA105 dfa105;
	DFA228 dfa228;
	DFA227 dfa227;
	DFA231 dfa231;
	DFA239 dfa239;
	DFA240 dfa240;
	DFA257 dfa257;
	DFA269 dfa269;

	protected override void InitDFAs()
	{
		base.InitDFAs();
		dfa21 = new DFA21( this );
		dfa20 = new DFA20( this, SpecialStateTransition20 );
		dfa27 = new DFA27( this, SpecialStateTransition27 );
		dfa29 = new DFA29( this, SpecialStateTransition29 );
		dfa38 = new DFA38( this, SpecialStateTransition38 );
		dfa46 = new DFA46( this, SpecialStateTransition46 );
		dfa50 = new DFA50( this );
		dfa71 = new DFA71( this, SpecialStateTransition71 );
		dfa72 = new DFA72( this, SpecialStateTransition72 );
		dfa101 = new DFA101( this, SpecialStateTransition101 );
		dfa103 = new DFA103( this, SpecialStateTransition103 );
		dfa104 = new DFA104( this );
		dfa105 = new DFA105( this, SpecialStateTransition105 );
		dfa228 = new DFA228( this );
		dfa227 = new DFA227( this, SpecialStateTransition227 );
		dfa231 = new DFA231( this );
		dfa239 = new DFA239( this, SpecialStateTransition239 );
		dfa240 = new DFA240( this );
		dfa257 = new DFA257( this, SpecialStateTransition257 );
		dfa269 = new DFA269( this, SpecialStateTransition269 );
	}

	private class DFA21 : DFA
	{
		private const string DFA21_eotS =
			"\x11\xFFFF";
		private const string DFA21_eofS =
			"\x11\xFFFF";
		private const string DFA21_minS =
			"\x1\x4\x4\xFFFF\x1\x4\x1\xFFFF\x2\x4\x8\xFFFF";
		private const string DFA21_maxS =
			"\x1\xCA\x4\xFFFF\x1\xCA\x1\xFFFF\x2\xCA\x8\xFFFF";
		private const string DFA21_acceptS =
			"\x1\xFFFF\x1\x1\x1\x2\x1\x3\x1\x4\x1\xFFFF\x1\x6\x2\xFFFF\x1\x7\x1\x8"+
			"\x1\x9\x1\xA\x1\xB\x1\xD\x1\x5\x1\xC";
		private const string DFA21_specialS =
			"\x11\xFFFF}>";
		private static readonly string[] DFA21_transitionS =
			{
				"\x1\x7\xE\xFFFF\x1\xB\x1\xFFFF\x4\x8\x28\xFFFF\x1\x8\x1\xFFFF\x1\x3"+
				"\xD\xFFFF\x1\x1\x1\x5\x10\xFFFF\x1\xC\x6\xFFFF\x1\xE\x19\xFFFF\x2\x8"+
				"\x1\xFFFF\xE\x8\x1\x2\x3\x8\x1\xFFFF\x1\x8\x1\x9\x4\x8\x9\x6\x1\xA\x1"+
				"\x8\x1\xFFFF\x1\x4\x1\xFFFF\x2\xD\x1\xFFFF\x2\x8\x10\xFFFF\x1\x8\x6"+
				"\x6\x1\x8",
				"",
				"",
				"",
				"",
				"\xA\xF\x7\xFFFF\x4\xF\x28\xFFFF\x1\xF\x24\xFFFF\x1\x6\x1D\xFFFF\x2"+
				"\xF\x1\xFFFF\xE\xF\x1\xFFFF\x3\xF\x1\xFFFF\x1\xF\x1\xFFFF\xD\xF\x1\xFFFF"+
				"\x1\xF\x6\xFFFF\x2\xF\x10\xFFFF\x8\xF",
				"",
				"\xB\x6\x6\xFFFF\x4\x6\x28\xFFFF\x1\x6\x11\xFFFF\x1\x6\x1\xFFFF\x1"+
				"\x6\x2\xFFFF\x1\x6\x1\xFFFF\x1\x10\xA\xFFFF\x3\x6\x1C\xFFFF\x2\x6\x1"+
				"\xFFFF\xE\x6\x1\xFFFF\x3\x6\x1\xFFFF\x1\x6\x1\xFFFF\xD\x6\x1\xFFFF\x1"+
				"\x6\x2\xFFFF\x1\x6\x3\xFFFF\x2\x6\x10\xFFFF\x8\x6",
				"\xB\x6\x6\xFFFF\x4\x6\x28\xFFFF\x1\x6\x11\xFFFF\x1\x6\x1\xFFFF\x1"+
				"\x6\x2\xFFFF\x1\x6\x1\xFFFF\x1\x10\xA\xFFFF\x3\x6\x1C\xFFFF\x2\x6\x1"+
				"\xFFFF\xE\x6\x1\xFFFF\x3\x6\x1\xFFFF\x1\x6\x1\xFFFF\xD\x6\x1\xFFFF\x1"+
				"\x6\x2\xFFFF\x1\x6\x3\xFFFF\x2\x6\x10\xFFFF\x8\x6",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA21_eot = DFA.UnpackEncodedString(DFA21_eotS);
		private static readonly short[] DFA21_eof = DFA.UnpackEncodedString(DFA21_eofS);
		private static readonly char[] DFA21_min = DFA.UnpackEncodedStringToUnsignedChars(DFA21_minS);
		private static readonly char[] DFA21_max = DFA.UnpackEncodedStringToUnsignedChars(DFA21_maxS);
		private static readonly short[] DFA21_accept = DFA.UnpackEncodedString(DFA21_acceptS);
		private static readonly short[] DFA21_special = DFA.UnpackEncodedString(DFA21_specialS);
		private static readonly short[][] DFA21_transition;

		static DFA21()
		{
			int numStates = DFA21_transitionS.Length;
			DFA21_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA21_transition[i] = DFA.UnpackEncodedString(DFA21_transitionS[i]);
			}
		}

		public DFA21( BaseRecognizer recognizer )
		{
			this.recognizer = recognizer;
			this.decisionNumber = 21;
			this.eot = DFA21_eot;
			this.eof = DFA21_eof;
			this.min = DFA21_min;
			this.max = DFA21_max;
			this.accept = DFA21_accept;
			this.special = DFA21_special;
			this.transition = DFA21_transition;
		}

		public override string Description { get { return "83:2: ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( 'void' method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | class_declaration | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration | destructor_declaration )"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private class DFA20 : DFA
	{
		private const string DFA20_eotS =
			"\xB\xFFFF";
		private const string DFA20_eofS =
			"\xB\xFFFF";
		private const string DFA20_minS =
			"\x1\x4\x4\x0\x6\xFFFF";
		private const string DFA20_maxS =
			"\x1\xCA\x4\x0\x6\xFFFF";
		private const string DFA20_acceptS =
			"\x5\xFFFF\x1\x4\x1\x6\x1\x1\x1\x2\x1\x3\x1\x5";
		private const string DFA20_specialS =
			"\x1\xFFFF\x1\x0\x1\x1\x1\x2\x1\x3\x6\xFFFF}>";
		private static readonly string[] DFA20_transitionS =
			{
				"\x1\x2\x9\x4\x7\xFFFF\x4\x3\x28\xFFFF\x1\x3\x11\xFFFF\x1\x5\x30\xFFFF"+
				"\x2\x3\x1\xFFFF\xE\x3\x1\xFFFF\x3\x3\x1\xFFFF\x1\x3\x1\xFFFF\x4\x3\x9"+
				"\x1\x1\xFFFF\x1\x3\x2\xFFFF\x1\x6\x3\xFFFF\x2\x3\x10\xFFFF\x1\x3\x6"+
				"\x1\x1\x3",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA20_eot = DFA.UnpackEncodedString(DFA20_eotS);
		private static readonly short[] DFA20_eof = DFA.UnpackEncodedString(DFA20_eofS);
		private static readonly char[] DFA20_min = DFA.UnpackEncodedStringToUnsignedChars(DFA20_minS);
		private static readonly char[] DFA20_max = DFA.UnpackEncodedStringToUnsignedChars(DFA20_maxS);
		private static readonly short[] DFA20_accept = DFA.UnpackEncodedString(DFA20_acceptS);
		private static readonly short[] DFA20_special = DFA.UnpackEncodedString(DFA20_specialS);
		private static readonly short[][] DFA20_transition;

		static DFA20()
		{
			int numStates = DFA20_transitionS.Length;
			DFA20_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA20_transition[i] = DFA.UnpackEncodedString(DFA20_transitionS[i]);
			}
		}

		public DFA20( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 20;
			this.eot = DFA20_eot;
			this.eof = DFA20_eof;
			this.min = DFA20_min;
			this.max = DFA20_max;
			this.accept = DFA20_accept;
			this.special = DFA20_special;
			this.transition = DFA20_transition;
		}

		public override string Description { get { return "91:9: ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition20(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA20_1 = input.LA(1);


				int index20_1 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred2_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred3_cs_fragment)) ) {s = 8;}


				input.Seek(index20_1);
				if ( s>=0 ) return s;
				break;
			case 1:
				int LA20_2 = input.LA(1);


				int index20_2 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred2_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred3_cs_fragment)) ) {s = 8;}

				else if ( (EvaluatePredicate(synpred4_cs_fragment)) ) {s = 9;}

				else if ( (true) ) {s = 10;}


				input.Seek(index20_2);
				if ( s>=0 ) return s;
				break;
			case 2:
				int LA20_3 = input.LA(1);


				int index20_3 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred2_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred3_cs_fragment)) ) {s = 8;}

				else if ( (EvaluatePredicate(synpred4_cs_fragment)) ) {s = 9;}

				else if ( (true) ) {s = 10;}


				input.Seek(index20_3);
				if ( s>=0 ) return s;
				break;
			case 3:
				int LA20_4 = input.LA(1);


				int index20_4 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred2_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred3_cs_fragment)) ) {s = 8;}


				input.Seek(index20_4);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 20, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA27 : DFA
	{
		private const string DFA27_eotS =
			"\x11\xFFFF";
		private const string DFA27_eofS =
			"\x11\xFFFF";
		private const string DFA27_minS =
			"\x1\x4\x2\x0\xE\xFFFF";
		private const string DFA27_maxS =
			"\x1\xCA\x2\x0\xE\xFFFF";
		private const string DFA27_acceptS =
			"\x3\xFFFF\x1\x3\x5\xFFFF\x1\x4\x1\x5\x1\x6\x1\x7\x1\x8\x1\x9\x1\x1\x1"+
			"\x2";
		private const string DFA27_specialS =
			"\x1\xFFFF\x1\x0\x1\x1\xE\xFFFF}>";
		private static readonly string[] DFA27_transitionS =
			{
				"\xA\x3\x7\xFFFF\x4\x3\x28\xFFFF\x1\x3\x2\xFFFF\x1\x9\xE\xFFFF\x1\x1"+
				"\x1\x2\x5\xFFFF\x1\x3\x4\xFFFF\x1\xA\x1\xB\x1\xC\x1\xD\x1\xE\x1\x3\x1F"+
				"\xFFFF\x2\x3\x1\xFFFF\xE\x3\x1\xFFFF\x3\x3\x1\xFFFF\x1\x3\x1\xFFFF\xD"+
				"\x3\x1\xFFFF\x1\x3\x6\xFFFF\x2\x3\x10\xFFFF\x8\x3",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA27_eot = DFA.UnpackEncodedString(DFA27_eotS);
		private static readonly short[] DFA27_eof = DFA.UnpackEncodedString(DFA27_eofS);
		private static readonly char[] DFA27_min = DFA.UnpackEncodedStringToUnsignedChars(DFA27_minS);
		private static readonly char[] DFA27_max = DFA.UnpackEncodedStringToUnsignedChars(DFA27_maxS);
		private static readonly short[] DFA27_accept = DFA.UnpackEncodedString(DFA27_acceptS);
		private static readonly short[] DFA27_special = DFA.UnpackEncodedString(DFA27_specialS);
		private static readonly short[][] DFA27_transition;

		static DFA27()
		{
			int numStates = DFA27_transitionS.Length;
			DFA27_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA27_transition[i] = DFA.UnpackEncodedString(DFA27_transitionS[i]);
			}
		}

		public DFA27( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 27;
			this.eot = DFA27_eot;
			this.eof = DFA27_eof;
			this.min = DFA27_min;
			this.max = DFA27_max;
			this.accept = DFA27_accept;
			this.special = DFA27_special;
			this.transition = DFA27_transition;
		}

		public override string Description { get { return "110:8: public primary_expression : ( ( 'this' brackets )=> 'this' brackets ( primary_expression_part )* | ( 'base' brackets )=> 'base' brackets ( primary_expression_part )* | primary_expression_start ( primary_expression_part )* | 'new' ( ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+ | ( delegate_creation_expression )=> delegate_creation_expression | object_creation_expression | anonymous_object_creation_expression ) | sizeof_expression | checked_expression | unchecked_expression | default_value_expression | anonymous_method_expression );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition27(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA27_1 = input.LA(1);


				int index27_1 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred5_cs_fragment)) ) {s = 15;}

				else if ( (true) ) {s = 3;}


				input.Seek(index27_1);
				if ( s>=0 ) return s;
				break;
			case 1:
				int LA27_2 = input.LA(1);


				int index27_2 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred6_cs_fragment)) ) {s = 16;}

				else if ( (true) ) {s = 3;}


				input.Seek(index27_2);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 27, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA29 : DFA
	{
		private const string DFA29_eotS =
			"\xB\xFFFF";
		private const string DFA29_eofS =
			"\xB\xFFFF";
		private const string DFA29_minS =
			"\x1\x4\x1\xFFFF\x2\x0\x7\xFFFF";
		private const string DFA29_maxS =
			"\x1\xCA\x1\xFFFF\x2\x0\x7\xFFFF";
		private const string DFA29_acceptS =
			"\x1\xFFFF\x1\x1\x2\xFFFF\x1\x4\x1\x5\x1\x6\x1\x7\x1\x8\x1\x2\x1\x3";
		private const string DFA29_specialS =
			"\x2\xFFFF\x1\x0\x1\x1\x7\xFFFF}>";
		private static readonly string[] DFA29_transitionS =
			{
				"\x1\x2\x9\x8\x7\xFFFF\x4\x3\x28\xFFFF\x1\x3\x11\xFFFF\x1\x4\x1\x5\x5"+
				"\xFFFF\x1\x6\x9\xFFFF\x1\x7\x1F\xFFFF\x2\x3\x1\xFFFF\xE\x3\x1\xFFFF"+
				"\x3\x3\x1\xFFFF\x1\x3\x1\xFFFF\x4\x3\x9\x1\x1\xFFFF\x1\x3\x6\xFFFF\x2"+
				"\x3\x10\xFFFF\x1\x3\x6\x1\x1\x3",
				"",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA29_eot = DFA.UnpackEncodedString(DFA29_eotS);
		private static readonly short[] DFA29_eof = DFA.UnpackEncodedString(DFA29_eofS);
		private static readonly char[] DFA29_min = DFA.UnpackEncodedStringToUnsignedChars(DFA29_minS);
		private static readonly char[] DFA29_max = DFA.UnpackEncodedStringToUnsignedChars(DFA29_maxS);
		private static readonly short[] DFA29_accept = DFA.UnpackEncodedString(DFA29_acceptS);
		private static readonly short[] DFA29_special = DFA.UnpackEncodedString(DFA29_specialS);
		private static readonly short[][] DFA29_transition;

		static DFA29()
		{
			int numStates = DFA29_transitionS.Length;
			DFA29_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA29_transition[i] = DFA.UnpackEncodedString(DFA29_transitionS[i]);
			}
		}

		public DFA29( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 29;
			this.eot = DFA29_eot;
			this.eof = DFA29_eof;
			this.min = DFA29_min;
			this.max = DFA29_max;
			this.accept = DFA29_accept;
			this.special = DFA29_special;
			this.transition = DFA29_transition;
		}

		public override string Description { get { return "128:8: public primary_expression_start : ( predefined_type | ( identifier generic_argument_list )=> identifier generic_argument_list | identifier ( '::' identifier )? | 'this' | 'base' | paren_expression | typeof_expression | literal );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition29(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA29_2 = input.LA(1);


				int index29_2 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred9_cs_fragment)) ) {s = 9;}

				else if ( (true) ) {s = 10;}


				input.Seek(index29_2);
				if ( s>=0 ) return s;
				break;
			case 1:
				int LA29_3 = input.LA(1);


				int index29_3 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred9_cs_fragment)) ) {s = 9;}

				else if ( (true) ) {s = 10;}


				input.Seek(index29_3);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 29, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA38 : DFA
	{
		private const string DFA38_eotS =
			"\x19\xFFFF";
		private const string DFA38_eofS =
			"\x19\xFFFF";
		private const string DFA38_minS =
			"\x1\x4\x1\x0\x17\xFFFF";
		private const string DFA38_maxS =
			"\x1\xCA\x1\x0\x17\xFFFF";
		private const string DFA38_acceptS =
			"\x2\xFFFF\x1\x2\x15\xFFFF\x1\x1";
		private const string DFA38_specialS =
			"\x1\xFFFF\x1\x0\x17\xFFFF}>";
		private static readonly string[] DFA38_transitionS =
			{
				"\xA\x2\x2\xFFFF\x1\x2\x4\xFFFF\x4\x2\x28\xFFFF\x1\x2\x2\xFFFF\x1\x2"+
				"\xE\xFFFF\x2\x2\x1\xFFFF\x2\x2\x2\xFFFF\x1\x1\x4\xFFFF\x6\x2\x1\xFFFF"+
				"\x1\x2\x1\xFFFF\x3\x2\xA\xFFFF\x1\x2\xE\xFFFF\x2\x2\x1\xFFFF\xE\x2\x1"+
				"\xFFFF\x3\x2\x1\xFFFF\x1\x2\x1\xFFFF\xD\x2\x1\xFFFF\x1\x2\x6\xFFFF\x2"+
				"\x2\x10\xFFFF\x8\x2",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA38_eot = DFA.UnpackEncodedString(DFA38_eotS);
		private static readonly short[] DFA38_eof = DFA.UnpackEncodedString(DFA38_eofS);
		private static readonly char[] DFA38_min = DFA.UnpackEncodedStringToUnsignedChars(DFA38_minS);
		private static readonly char[] DFA38_max = DFA.UnpackEncodedStringToUnsignedChars(DFA38_maxS);
		private static readonly short[] DFA38_accept = DFA.UnpackEncodedString(DFA38_acceptS);
		private static readonly short[] DFA38_special = DFA.UnpackEncodedString(DFA38_specialS);
		private static readonly short[][] DFA38_transition;

		static DFA38()
		{
			int numStates = DFA38_transitionS.Length;
			DFA38_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA38_transition[i] = DFA.UnpackEncodedString(DFA38_transitionS[i]);
			}
		}

		public DFA38( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 38;
			this.eot = DFA38_eot;
			this.eof = DFA38_eof;
			this.min = DFA38_min;
			this.max = DFA38_max;
			this.accept = DFA38_accept;
			this.special = DFA38_special;
			this.transition = DFA38_transition;
		}

		public override string Description { get { return "170:3: ( ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference ) | variable_reference )"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition38(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA38_1 = input.LA(1);


				int index38_1 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred10_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 2;}


				input.Seek(index38_1);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 38, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA46 : DFA
	{
		private const string DFA46_eotS =
			"\x10\xFFFF";
		private const string DFA46_eofS =
			"\x10\xFFFF";
		private const string DFA46_minS =
			"\x1\x4\x1\x0\xE\xFFFF";
		private const string DFA46_maxS =
			"\x1\xCA\x1\x0\xE\xFFFF";
		private const string DFA46_acceptS =
			"\x2\xFFFF\x1\x2\xC\xFFFF\x1\x1";
		private const string DFA46_specialS =
			"\x1\xFFFF\x1\x0\xE\xFFFF}>";
		private static readonly string[] DFA46_transitionS =
			{
				"\xA\x2\x7\xFFFF\x4\x2\x28\xFFFF\x1\x2\x2\xFFFF\x1\x1\xE\xFFFF\x2\x2"+
				"\x5\xFFFF\x1\x2\x4\xFFFF\x6\x2\x1F\xFFFF\x2\x2\x1\xFFFF\xE\x2\x1\xFFFF"+
				"\x3\x2\x1\xFFFF\x1\x2\x1\xFFFF\xD\x2\x1\xFFFF\x1\x2\x6\xFFFF\x2\x2\x10"+
				"\xFFFF\x8\x2",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA46_eot = DFA.UnpackEncodedString(DFA46_eotS);
		private static readonly short[] DFA46_eof = DFA.UnpackEncodedString(DFA46_eofS);
		private static readonly char[] DFA46_min = DFA.UnpackEncodedStringToUnsignedChars(DFA46_minS);
		private static readonly char[] DFA46_max = DFA.UnpackEncodedStringToUnsignedChars(DFA46_maxS);
		private static readonly short[] DFA46_accept = DFA.UnpackEncodedString(DFA46_acceptS);
		private static readonly short[] DFA46_special = DFA.UnpackEncodedString(DFA46_specialS);
		private static readonly short[][] DFA46_transition;

		static DFA46()
		{
			int numStates = DFA46_transitionS.Length;
			DFA46_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA46_transition[i] = DFA.UnpackEncodedString(DFA46_transitionS[i]);
			}
		}

		public DFA46( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 46;
			this.eot = DFA46_eot;
			this.eof = DFA46_eof;
			this.min = DFA46_min;
			this.max = DFA46_max;
			this.accept = DFA46_accept;
			this.special = DFA46_special;
			this.transition = DFA46_transition;
		}

		public override string Description { get { return "195:8: public primary_or_array_creation_expression : ( ( array_creation_expression )=> array_creation_expression | primary_expression );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition46(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA46_1 = input.LA(1);


				int index46_1 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred11_cs_fragment)) ) {s = 15;}

				else if ( (true) ) {s = 2;}


				input.Seek(index46_1);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 46, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA50 : DFA
	{
		private const string DFA50_eotS =
			"\x5\xFFFF";
		private const string DFA50_eofS =
			"\x1\x2\x3\xFFFF\x1\x2";
		private const string DFA50_minS =
			"\x2\x4\x2\xFFFF\x1\x4";
		private const string DFA50_maxS =
			"\x2\xCA\x2\xFFFF\x1\xCA";
		private const string DFA50_acceptS =
			"\x2\xFFFF\x1\x1\x1\x2\x1\xFFFF";
		private const string DFA50_specialS =
			"\x5\xFFFF}>";
		private static readonly string[] DFA50_transitionS =
			{
				"\x1\x2\x9\xFFFF\x2\x3\x2\x2\x3\xFFFF\x6\x2\x23\xFFFF\x2\x2\x1\xFFFF"+
				"\x2\x2\x15\xFFFF\x1\x1\x1\x2\x1\x3\x2\x2\x8\xFFFF\x4\x2\x2\xFFFF\x18"+
				"\x2\x1\xFFFF\x2\x2\x1\xFFFF\xE\x2\x1\xFFFF\x3\x2\x1\xFFFF\x1\x2\x1\xFFFF"+
				"\x4\x2\xA\xFFFF\x1\x2\x6\xFFFF\x2\x2\x10\xFFFF\x1\x2\x6\xFFFF\x1\x2",
				"\xA\x3\x2\xFFFF\x1\x3\x4\xFFFF\x4\x3\x28\xFFFF\x1\x3\x2\xFFFF\x1\x3"+
				"\xE\xFFFF\x2\x3\x1\xFFFF\x2\x3\x1\xFFFF\x1\x4\x1\x3\x1\x2\x3\xFFFF\x6"+
				"\x3\x1\xFFFF\x1\x3\x1\xFFFF\x3\x3\xA\xFFFF\x1\x3\xE\xFFFF\x2\x3\x1\xFFFF"+
				"\xE\x3\x1\xFFFF\x3\x3\x1\xFFFF\x1\x3\x1\xFFFF\xD\x3\x1\xFFFF\x1\x3\x6"+
				"\xFFFF\x2\x3\x10\xFFFF\x8\x3",
				"",
				"",
				"\x1\x2\x9\xFFFF\x2\x3\x2\x2\x3\xFFFF\x6\x2\x23\xFFFF\x2\x2\x1\xFFFF"+
				"\x2\x2\x15\xFFFF\x1\x1\x1\x2\x1\x3\x2\x2\x8\xFFFF\x4\x2\x2\xFFFF\x18"+
				"\x2\x1\xFFFF\x2\x2\x1\xFFFF\xE\x2\x1\xFFFF\x3\x2\x1\xFFFF\x1\x2\x1\xFFFF"+
				"\x4\x2\xA\xFFFF\x1\x2\x6\xFFFF\x2\x2\x10\xFFFF\x1\x2\x6\xFFFF\x1\x2"
			};

		private static readonly short[] DFA50_eot = DFA.UnpackEncodedString(DFA50_eotS);
		private static readonly short[] DFA50_eof = DFA.UnpackEncodedString(DFA50_eofS);
		private static readonly char[] DFA50_min = DFA.UnpackEncodedStringToUnsignedChars(DFA50_minS);
		private static readonly char[] DFA50_max = DFA.UnpackEncodedStringToUnsignedChars(DFA50_maxS);
		private static readonly short[] DFA50_accept = DFA.UnpackEncodedString(DFA50_acceptS);
		private static readonly short[] DFA50_special = DFA.UnpackEncodedString(DFA50_specialS);
		private static readonly short[][] DFA50_transition;

		static DFA50()
		{
			int numStates = DFA50_transitionS.Length;
			DFA50_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA50_transition[i] = DFA.UnpackEncodedString(DFA50_transitionS[i]);
			}
		}

		public DFA50( BaseRecognizer recognizer )
		{
			this.recognizer = recognizer;
			this.decisionNumber = 50;
			this.eot = DFA50_eot;
			this.eof = DFA50_eof;
			this.min = DFA50_min;
			this.max = DFA50_max;
			this.accept = DFA50_accept;
			this.special = DFA50_special;
			this.transition = DFA50_transition;
		}

		public override string Description { get { return "203:6: ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments )"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private class DFA71 : DFA
	{
		private const string DFA71_eotS =
			"\x11\xFFFF";
		private const string DFA71_eofS =
			"\x11\xFFFF";
		private const string DFA71_minS =
			"\x1\x4\x2\xE\x1\xFFFF\x1\x1A\x3\x4\x1\xFFFF\x2\xE\x2\xFFFF\x2\xE\x2"+
			"\x4";
		private const string DFA71_maxS =
			"\x1\xCA\x2\x67\x1\xFFFF\x1\x66\x3\xCA\x1\xFFFF\x2\x67\x2\xFFFF\x2\x67"+
			"\x2\xCA";
		private const string DFA71_acceptS =
			"\x3\xFFFF\x1\x2\x4\xFFFF\x1\x3\x2\xFFFF\x2\x1\x4\xFFFF";
		private const string DFA71_specialS =
			"\x6\xFFFF\x1\x2\x8\xFFFF\x1\x1\x1\x0}>";
		private static readonly string[] DFA71_transitionS =
			{
				"\x1\x1\x10\xFFFF\x4\x2\x28\xFFFF\x1\x2\x10\xFFFF\x1\x4\x31\xFFFF\x2"+
				"\x2\x1\xFFFF\xE\x2\x1\xFFFF\x3\x2\x1\xFFFF\x1\x2\x1\xFFFF\x4\x2\x9\x3"+
				"\x1\xFFFF\x1\x2\x6\xFFFF\x2\x2\x10\xFFFF\x1\x2\x6\x3\x1\x2",
				"\x1\x7\xB\xFFFF\x1\x3\x3A\xFFFF\x1\x5\x2\xFFFF\x1\x3\xC\xFFFF\x1\x6"+
				"\x2\x3",
				"\x1\x7\xB\xFFFF\x1\x3\x3A\xFFFF\x1\x5\x2\xFFFF\x1\x3\xC\xFFFF\x1\x6"+
				"\x2\x3",
				"",
				"\x1\x8\x4B\xFFFF\x1\x3",
				"\x1\x9\x10\xFFFF\x4\xA\x28\xFFFF\x1\xA\x42\xFFFF\x2\xA\x1\xFFFF\xE"+
				"\xA\x1\xFFFF\x3\xA\x1\xFFFF\x1\xA\x1\xFFFF\x4\xA\xA\xFFFF\x1\xA\x6\xFFFF"+
				"\x2\xA\x10\xFFFF\x1\xA\x6\xFFFF\x1\xA",
				"\x1\x3\xC\xFFFF\x1\xC\x3\xFFFF\x4\x3\x28\xFFFF\x1\x3\x10\xFFFF\x1"+
				"\x3\x8\xFFFF\x1\xB\x28\xFFFF\x2\x3\x1\xFFFF\xE\x3\x1\xFFFF\x3\x3\x1"+
				"\xFFFF\x1\x3\x1\xFFFF\xD\x3\x1\xFFFF\x1\x3\x6\xFFFF\x2\x3\x10\xFFFF"+
				"\x8\x3",
				"\x1\xD\x10\xFFFF\x4\xE\x28\xFFFF\x1\xE\x42\xFFFF\x2\xE\x1\xFFFF\xE"+
				"\xE\x1\xFFFF\x3\xE\x1\xFFFF\x1\xE\x1\xFFFF\x4\xE\xA\xFFFF\x1\xE\x6\xFFFF"+
				"\x2\xE\x10\xFFFF\x1\xE\x6\xFFFF\x1\xE",
				"",
				"\x1\x7\xB\xFFFF\x1\x3\x3D\xFFFF\x1\x3\xC\xFFFF\x1\xF\x2\x3",
				"\x1\x7\xB\xFFFF\x1\x3\x3D\xFFFF\x1\x3\xC\xFFFF\x1\xF\x2\x3",
				"",
				"",
				"\x1\x7\xB\xFFFF\x1\x3\x3D\xFFFF\x1\x3\xC\xFFFF\x1\x10\x2\x3",
				"\x1\x7\xB\xFFFF\x1\x3\x3D\xFFFF\x1\x3\xC\xFFFF\x1\x10\x2\x3",
				"\x1\x3\xC\xFFFF\x1\xC\x3\xFFFF\x4\x3\x28\xFFFF\x1\x3\x10\xFFFF\x1"+
				"\x3\x8\xFFFF\x1\xB\x28\xFFFF\x2\x3\x1\xFFFF\xE\x3\x1\xFFFF\x3\x3\x1"+
				"\xFFFF\x1\x3\x1\xFFFF\xD\x3\x1\xFFFF\x1\x3\x6\xFFFF\x2\x3\x10\xFFFF"+
				"\x8\x3",
				"\x1\x3\xC\xFFFF\x1\xC\x3\xFFFF\x4\x3\x28\xFFFF\x1\x3\x10\xFFFF\x1"+
				"\x3\x8\xFFFF\x1\xB\x28\xFFFF\x2\x3\x1\xFFFF\xE\x3\x1\xFFFF\x3\x3\x1"+
				"\xFFFF\x1\x3\x1\xFFFF\xD\x3\x1\xFFFF\x1\x3\x6\xFFFF\x2\x3\x10\xFFFF"+
				"\x8\x3"
			};

		private static readonly short[] DFA71_eot = DFA.UnpackEncodedString(DFA71_eotS);
		private static readonly short[] DFA71_eof = DFA.UnpackEncodedString(DFA71_eofS);
		private static readonly char[] DFA71_min = DFA.UnpackEncodedStringToUnsignedChars(DFA71_minS);
		private static readonly char[] DFA71_max = DFA.UnpackEncodedStringToUnsignedChars(DFA71_maxS);
		private static readonly short[] DFA71_accept = DFA.UnpackEncodedString(DFA71_acceptS);
		private static readonly short[] DFA71_special = DFA.UnpackEncodedString(DFA71_specialS);
		private static readonly short[][] DFA71_transition;

		static DFA71()
		{
			int numStates = DFA71_transitionS.Length;
			DFA71_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA71_transition[i] = DFA.UnpackEncodedString(DFA71_transitionS[i]);
			}
		}

		public DFA71( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 71;
			this.eot = DFA71_eot;
			this.eof = DFA71_eof;
			this.min = DFA71_min;
			this.max = DFA71_max;
			this.accept = DFA71_accept;
			this.special = DFA71_special;
			this.transition = DFA71_transition;
		}

		public override string Description { get { return "276:19: ( ( unbound_type_name )=> unbound_type_name | type | 'void' )"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition71(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA71_16 = input.LA(1);


				int index71_16 = input.Index;
				input.Rewind();
				s = -1;
				if ( (LA71_16==91) && (EvaluatePredicate(synpred13_cs_fragment))) {s = 11;}

				else if ( (LA71_16==GT) && (EvaluatePredicate(synpred13_cs_fragment))) {s = 12;}

				else if ( (LA71_16==IDENTIFIER||(LA71_16>=ELIF && LA71_16<=UNDEF)||LA71_16==65||LA71_16==82||(LA71_16>=132 && LA71_16<=133)||(LA71_16>=135 && LA71_16<=148)||(LA71_16>=150 && LA71_16<=152)||LA71_16==154||(LA71_16>=156 && LA71_16<=168)||LA71_16==170||(LA71_16>=177 && LA71_16<=178)||(LA71_16>=195 && LA71_16<=202)) ) {s = 3;}


				input.Seek(index71_16);
				if ( s>=0 ) return s;
				break;
			case 1:
				int LA71_15 = input.LA(1);


				int index71_15 = input.Index;
				input.Rewind();
				s = -1;
				if ( (LA71_15==91) && (EvaluatePredicate(synpred13_cs_fragment))) {s = 11;}

				else if ( (LA71_15==GT) && (EvaluatePredicate(synpred13_cs_fragment))) {s = 12;}

				else if ( (LA71_15==IDENTIFIER||(LA71_15>=ELIF && LA71_15<=UNDEF)||LA71_15==65||LA71_15==82||(LA71_15>=132 && LA71_15<=133)||(LA71_15>=135 && LA71_15<=148)||(LA71_15>=150 && LA71_15<=152)||LA71_15==154||(LA71_15>=156 && LA71_15<=168)||LA71_15==170||(LA71_15>=177 && LA71_15<=178)||(LA71_15>=195 && LA71_15<=202)) ) {s = 3;}


				input.Seek(index71_15);
				if ( s>=0 ) return s;
				break;
			case 2:
				int LA71_6 = input.LA(1);


				int index71_6 = input.Index;
				input.Rewind();
				s = -1;
				if ( (LA71_6==91) && (EvaluatePredicate(synpred13_cs_fragment))) {s = 11;}

				else if ( (LA71_6==GT) && (EvaluatePredicate(synpred13_cs_fragment))) {s = 12;}

				else if ( (LA71_6==IDENTIFIER||(LA71_6>=ELIF && LA71_6<=UNDEF)||LA71_6==65||LA71_6==82||(LA71_6>=132 && LA71_6<=133)||(LA71_6>=135 && LA71_6<=148)||(LA71_6>=150 && LA71_6<=152)||LA71_6==154||(LA71_6>=156 && LA71_6<=168)||LA71_6==170||(LA71_6>=177 && LA71_6<=178)||(LA71_6>=195 && LA71_6<=202)) ) {s = 3;}


				input.Seek(index71_6);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 71, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA72 : DFA
	{
		private const string DFA72_eotS =
			"\x7\xFFFF";
		private const string DFA72_eofS =
			"\x4\xFFFF\x1\x5\x2\xFFFF";
		private const string DFA72_minS =
			"\x1\xE\x1\x11\x1\xFFFF\x1\x11\x1\xE\x2\xFFFF";
		private const string DFA72_maxS =
			"\x1\x65\x1\x5B\x1\xFFFF\x1\x5B\x1\x1A\x2\xFFFF";
		private const string DFA72_acceptS =
			"\x2\xFFFF\x1\x2\x2\xFFFF\x1\x3\x1\x1";
		private const string DFA72_specialS =
			"\x4\xFFFF\x1\x0\x2\xFFFF}>";
		private static readonly string[] DFA72_transitionS =
			{
				"\x1\x2\x56\xFFFF\x1\x1",
				"\x1\x4\x49\xFFFF\x1\x3",
				"",
				"\x1\x4\x49\xFFFF\x1\x3",
				"\x1\x6\xB\xFFFF\x1\x5",
				"",
				""
			};

		private static readonly short[] DFA72_eot = DFA.UnpackEncodedString(DFA72_eotS);
		private static readonly short[] DFA72_eof = DFA.UnpackEncodedString(DFA72_eofS);
		private static readonly char[] DFA72_min = DFA.UnpackEncodedStringToUnsignedChars(DFA72_minS);
		private static readonly char[] DFA72_max = DFA.UnpackEncodedStringToUnsignedChars(DFA72_maxS);
		private static readonly short[] DFA72_accept = DFA.UnpackEncodedString(DFA72_acceptS);
		private static readonly short[] DFA72_special = DFA.UnpackEncodedString(DFA72_specialS);
		private static readonly short[][] DFA72_transition;

		static DFA72()
		{
			int numStates = DFA72_transitionS.Length;
			DFA72_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA72_transition[i] = DFA.UnpackEncodedString(DFA72_transitionS[i]);
			}
		}

		public DFA72( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 72;
			this.eot = DFA72_eot;
			this.eof = DFA72_eof;
			this.min = DFA72_min;
			this.max = DFA72_max;
			this.accept = DFA72_accept;
			this.special = DFA72_special;
			this.transition = DFA72_transition;
		}

		public override string Description { get { return "()* loopback of 286:3: ( ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part ) | unbound_type_name_part )*"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition72(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA72_4 = input.LA(1);


				int index72_4 = input.Index;
				input.Rewind();
				s = -1;
				if ( (LA72_4==EOF||LA72_4==RPAREN) ) {s = 5;}

				else if ( (LA72_4==DOT) && (EvaluatePredicate(synpred14_cs_fragment))) {s = 6;}


				input.Seek(index72_4);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 72, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA101 : DFA
	{
		private const string DFA101_eotS =
			"\x1A\xFFFF";
		private const string DFA101_eofS =
			"\x1A\xFFFF";
		private const string DFA101_minS =
			"\x1\x4\x17\x0\x2\xFFFF";
		private const string DFA101_maxS =
			"\x1\xCA\x17\x0\x2\xFFFF";
		private const string DFA101_acceptS =
			"\x18\xFFFF\x1\x1\x1\x2";
		private const string DFA101_specialS =
			"\x1\xFFFF\x1\x0\x1\x1\x1\x2\x1\x3\x1\x4\x1\x5\x1\x6\x1\x7\x1\x8\x1\x9"+
			"\x1\xA\x1\xB\x1\xC\x1\xD\x1\xE\x1\xF\x1\x10\x1\x11\x1\x12\x1\x13\x1\x14"+
			"\x1\x15\x1\x16\x2\xFFFF}>";
		private static readonly string[] DFA101_transitionS =
			{
				"\x1\x6\x9\x9\x2\xFFFF\x1\x10\x4\xFFFF\x4\x17\x28\xFFFF\x1\x17\x2\xFFFF"+
				"\x1\x2\xE\xFFFF\x1\x3\x1\x4\x1\xFFFF\x1\x13\x1\x14\x2\xFFFF\x1\x1\x4"+
				"\xFFFF\x1\xA\x1\xB\x1\xC\x1\xD\x1\xE\x1\x8\x1\xFFFF\x1\x15\x1\xFFFF"+
				"\x1\xF\x1\x11\x1\x12\xA\xFFFF\x1\x16\xE\xFFFF\x1\x17\x1\x7\x1\xFFFF"+
				"\xE\x17\x1\xFFFF\x3\x17\x1\xFFFF\x1\x17\x1\xFFFF\x4\x17\x9\x5\x1\xFFFF"+
				"\x1\x17\x6\xFFFF\x2\x17\x10\xFFFF\x1\x17\x6\x5\x1\x17",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"",
				""
			};

		private static readonly short[] DFA101_eot = DFA.UnpackEncodedString(DFA101_eotS);
		private static readonly short[] DFA101_eof = DFA.UnpackEncodedString(DFA101_eofS);
		private static readonly char[] DFA101_min = DFA.UnpackEncodedStringToUnsignedChars(DFA101_minS);
		private static readonly char[] DFA101_max = DFA.UnpackEncodedStringToUnsignedChars(DFA101_maxS);
		private static readonly short[] DFA101_accept = DFA.UnpackEncodedString(DFA101_acceptS);
		private static readonly short[] DFA101_special = DFA.UnpackEncodedString(DFA101_specialS);
		private static readonly short[][] DFA101_transition;

		static DFA101()
		{
			int numStates = DFA101_transitionS.Length;
			DFA101_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA101_transition[i] = DFA.UnpackEncodedString(DFA101_transitionS[i]);
			}
		}

		public DFA101( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 101;
			this.eot = DFA101_eot;
			this.eof = DFA101_eof;
			this.min = DFA101_min;
			this.max = DFA101_max;
			this.accept = DFA101_accept;
			this.special = DFA101_special;
			this.transition = DFA101_transition;
		}

		public override string Description { get { return "370:8: public expression : ( ( unary_expression assignment_operator )=> assignment | non_assignment_expression );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition101(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA101_1 = input.LA(1);


				int index101_1 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_1);
				if ( s>=0 ) return s;
				break;
			case 1:
				int LA101_2 = input.LA(1);


				int index101_2 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_2);
				if ( s>=0 ) return s;
				break;
			case 2:
				int LA101_3 = input.LA(1);


				int index101_3 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_3);
				if ( s>=0 ) return s;
				break;
			case 3:
				int LA101_4 = input.LA(1);


				int index101_4 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_4);
				if ( s>=0 ) return s;
				break;
			case 4:
				int LA101_5 = input.LA(1);


				int index101_5 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_5);
				if ( s>=0 ) return s;
				break;
			case 5:
				int LA101_6 = input.LA(1);


				int index101_6 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_6);
				if ( s>=0 ) return s;
				break;
			case 6:
				int LA101_7 = input.LA(1);


				int index101_7 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_7);
				if ( s>=0 ) return s;
				break;
			case 7:
				int LA101_8 = input.LA(1);


				int index101_8 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_8);
				if ( s>=0 ) return s;
				break;
			case 8:
				int LA101_9 = input.LA(1);


				int index101_9 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_9);
				if ( s>=0 ) return s;
				break;
			case 9:
				int LA101_10 = input.LA(1);


				int index101_10 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_10);
				if ( s>=0 ) return s;
				break;
			case 10:
				int LA101_11 = input.LA(1);


				int index101_11 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_11);
				if ( s>=0 ) return s;
				break;
			case 11:
				int LA101_12 = input.LA(1);


				int index101_12 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_12);
				if ( s>=0 ) return s;
				break;
			case 12:
				int LA101_13 = input.LA(1);


				int index101_13 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_13);
				if ( s>=0 ) return s;
				break;
			case 13:
				int LA101_14 = input.LA(1);


				int index101_14 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_14);
				if ( s>=0 ) return s;
				break;
			case 14:
				int LA101_15 = input.LA(1);


				int index101_15 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_15);
				if ( s>=0 ) return s;
				break;
			case 15:
				int LA101_16 = input.LA(1);


				int index101_16 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_16);
				if ( s>=0 ) return s;
				break;
			case 16:
				int LA101_17 = input.LA(1);


				int index101_17 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_17);
				if ( s>=0 ) return s;
				break;
			case 17:
				int LA101_18 = input.LA(1);


				int index101_18 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_18);
				if ( s>=0 ) return s;
				break;
			case 18:
				int LA101_19 = input.LA(1);


				int index101_19 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_19);
				if ( s>=0 ) return s;
				break;
			case 19:
				int LA101_20 = input.LA(1);


				int index101_20 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_20);
				if ( s>=0 ) return s;
				break;
			case 20:
				int LA101_21 = input.LA(1);


				int index101_21 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_21);
				if ( s>=0 ) return s;
				break;
			case 21:
				int LA101_22 = input.LA(1);


				int index101_22 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_22);
				if ( s>=0 ) return s;
				break;
			case 22:
				int LA101_23 = input.LA(1);


				int index101_23 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred19_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 25;}


				input.Seek(index101_23);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 101, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA103 : DFA
	{
		private const string DFA103_eotS =
			"\x18\xFFFF";
		private const string DFA103_eofS =
			"\x18\xFFFF";
		private const string DFA103_minS =
			"\x1\x4\x1\x0\x16\xFFFF";
		private const string DFA103_maxS =
			"\x1\xCA\x1\x0\x16\xFFFF";
		private const string DFA103_acceptS =
			"\x2\xFFFF\x1\x2\xC\xFFFF\x1\x3\x1\x4\x1\x5\x1\x6\x1\x7\x1\x8\x1\x9\x1"+
			"\xA\x1\x1";
		private const string DFA103_specialS =
			"\x1\xFFFF\x1\x0\x16\xFFFF}>";
		private static readonly string[] DFA103_transitionS =
			{
				"\xA\x2\x2\xFFFF\x1\x10\x4\xFFFF\x4\x2\x28\xFFFF\x1\x2\x2\xFFFF\x1\x2"+
				"\xE\xFFFF\x2\x2\x1\xFFFF\x1\x13\x1\x14\x2\xFFFF\x1\x1\x4\xFFFF\x6\x2"+
				"\x1\xFFFF\x1\x15\x1\xFFFF\x1\xF\x1\x11\x1\x12\xA\xFFFF\x1\x16\xE\xFFFF"+
				"\x2\x2\x1\xFFFF\xE\x2\x1\xFFFF\x3\x2\x1\xFFFF\x1\x2\x1\xFFFF\xD\x2\x1"+
				"\xFFFF\x1\x2\x6\xFFFF\x2\x2\x10\xFFFF\x8\x2",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA103_eot = DFA.UnpackEncodedString(DFA103_eotS);
		private static readonly short[] DFA103_eof = DFA.UnpackEncodedString(DFA103_eofS);
		private static readonly char[] DFA103_min = DFA.UnpackEncodedStringToUnsignedChars(DFA103_minS);
		private static readonly char[] DFA103_max = DFA.UnpackEncodedStringToUnsignedChars(DFA103_maxS);
		private static readonly short[] DFA103_accept = DFA.UnpackEncodedString(DFA103_acceptS);
		private static readonly short[] DFA103_special = DFA.UnpackEncodedString(DFA103_specialS);
		private static readonly short[][] DFA103_transition;

		static DFA103()
		{
			int numStates = DFA103_transitionS.Length;
			DFA103_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA103_transition[i] = DFA.UnpackEncodedString(DFA103_transitionS[i]);
			}
		}

		public DFA103( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 103;
			this.eot = DFA103_eot;
			this.eof = DFA103_eof;
			this.min = DFA103_min;
			this.max = DFA103_max;
			this.accept = DFA103_accept;
			this.special = DFA103_special;
			this.transition = DFA103_transition;
		}

		public override string Description { get { return "378:8: public unary_expression : ( ( cast_expression )=> cast_expression | primary_or_array_creation_expression | '+' unary_expression | '-' unary_expression | '!' unary_expression | '~' unary_expression | pre_increment_expression | pre_decrement_expression | pointer_indirection_expression | addressof_expression );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition103(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA103_1 = input.LA(1);


				int index103_1 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred20_cs_fragment)) ) {s = 23;}

				else if ( (true) ) {s = 2;}


				input.Seek(index103_1);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 103, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA104 : DFA
	{
		private const string DFA104_eotS =
			"\xC\xFFFF";
		private const string DFA104_eofS =
			"\xC\xFFFF";
		private const string DFA104_minS =
			"\x1\x11\xB\xFFFF";
		private const string DFA104_maxS =
			"\x1\x73\xB\xFFFF";
		private const string DFA104_acceptS =
			"\x1\xFFFF\x1\x1\x1\x2\x1\x3\x1\x4\x1\x5\x1\x6\x1\x7\x1\x8\x1\x9\x1\xA"+
			"\x1\xB";
		private const string DFA104_specialS =
			"\xC\xFFFF}>";
		private static readonly string[] DFA104_transitionS =
			{
				"\x1\xB\x30\xFFFF\x1\x1\x28\xFFFF\x1\x2\x1\x3\x1\x4\x1\x5\x1\x6\x1\x7"+
				"\x1\x8\x1\x9\x1\xA",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA104_eot = DFA.UnpackEncodedString(DFA104_eotS);
		private static readonly short[] DFA104_eof = DFA.UnpackEncodedString(DFA104_eofS);
		private static readonly char[] DFA104_min = DFA.UnpackEncodedStringToUnsignedChars(DFA104_minS);
		private static readonly char[] DFA104_max = DFA.UnpackEncodedStringToUnsignedChars(DFA104_maxS);
		private static readonly short[] DFA104_accept = DFA.UnpackEncodedString(DFA104_acceptS);
		private static readonly short[] DFA104_special = DFA.UnpackEncodedString(DFA104_specialS);
		private static readonly short[][] DFA104_transition;

		static DFA104()
		{
			int numStates = DFA104_transitionS.Length;
			DFA104_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA104_transition[i] = DFA.UnpackEncodedString(DFA104_transitionS[i]);
			}
		}

		public DFA104( BaseRecognizer recognizer )
		{
			this.recognizer = recognizer;
			this.decisionNumber = 104;
			this.eot = DFA104_eot;
			this.eof = DFA104_eof;
			this.min = DFA104_min;
			this.max = DFA104_max;
			this.accept = DFA104_accept;
			this.special = DFA104_special;
			this.transition = DFA104_transition;
		}

		public override string Description { get { return "393:8: public assignment_operator : ( '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>' '>=' );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private class DFA105 : DFA
	{
		private const string DFA105_eotS =
			"\x1A\xFFFF";
		private const string DFA105_eofS =
			"\x1A\xFFFF";
		private const string DFA105_minS =
			"\x1\x4\x4\x0\x15\xFFFF";
		private const string DFA105_maxS =
			"\x1\xCA\x4\x0\x15\xFFFF";
		private const string DFA105_acceptS =
			"\x5\xFFFF\x1\x3\x12\xFFFF\x1\x1\x1\x2";
		private const string DFA105_specialS =
			"\x1\xFFFF\x1\x0\x1\x1\x1\x2\x1\x3\x15\xFFFF}>";
		private static readonly string[] DFA105_transitionS =
			{
				"\x1\x2\x9\x5\x2\xFFFF\x1\x5\x4\xFFFF\x4\x4\x28\xFFFF\x1\x4\x2\xFFFF"+
				"\x1\x5\xE\xFFFF\x2\x5\x1\xFFFF\x2\x5\x2\xFFFF\x1\x1\x4\xFFFF\x6\x5\x1"+
				"\xFFFF\x1\x5\x1\xFFFF\x3\x5\xA\xFFFF\x1\x5\xE\xFFFF\x1\x4\x1\x3\x1\xFFFF"+
				"\xE\x4\x1\xFFFF\x3\x4\x1\xFFFF\x1\x4\x1\xFFFF\x4\x4\x9\x5\x1\xFFFF\x1"+
				"\x4\x6\xFFFF\x2\x4\x10\xFFFF\x1\x4\x6\x5\x1\x4",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA105_eot = DFA.UnpackEncodedString(DFA105_eotS);
		private static readonly short[] DFA105_eof = DFA.UnpackEncodedString(DFA105_eofS);
		private static readonly char[] DFA105_min = DFA.UnpackEncodedStringToUnsignedChars(DFA105_minS);
		private static readonly char[] DFA105_max = DFA.UnpackEncodedStringToUnsignedChars(DFA105_maxS);
		private static readonly short[] DFA105_accept = DFA.UnpackEncodedString(DFA105_acceptS);
		private static readonly short[] DFA105_special = DFA.UnpackEncodedString(DFA105_specialS);
		private static readonly short[][] DFA105_transition;

		static DFA105()
		{
			int numStates = DFA105_transitionS.Length;
			DFA105_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA105_transition[i] = DFA.UnpackEncodedString(DFA105_transitionS[i]);
			}
		}

		public DFA105( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 105;
			this.eot = DFA105_eot;
			this.eof = DFA105_eof;
			this.min = DFA105_min;
			this.max = DFA105_max;
			this.accept = DFA105_accept;
			this.special = DFA105_special;
			this.transition = DFA105_transition;
		}

		public override string Description { get { return "404:8: public non_assignment_expression : ( ( anonymous_function_signature '=>' )=> lambda_expression | ( query_expression )=> query_expression | conditional_expression );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition105(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA105_1 = input.LA(1);


				int index105_1 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred21_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 5;}


				input.Seek(index105_1);
				if ( s>=0 ) return s;
				break;
			case 1:
				int LA105_2 = input.LA(1);


				int index105_2 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred21_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 5;}


				input.Seek(index105_2);
				if ( s>=0 ) return s;
				break;
			case 2:
				int LA105_3 = input.LA(1);


				int index105_3 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred21_cs_fragment)) ) {s = 24;}

				else if ( (EvaluatePredicate(synpred22_cs_fragment)) ) {s = 25;}

				else if ( (true) ) {s = 5;}


				input.Seek(index105_3);
				if ( s>=0 ) return s;
				break;
			case 3:
				int LA105_4 = input.LA(1);


				int index105_4 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred21_cs_fragment)) ) {s = 24;}

				else if ( (true) ) {s = 5;}


				input.Seek(index105_4);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 105, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA228 : DFA
	{
		private const string DFA228_eotS =
			"\x10\xFFFF";
		private const string DFA228_eofS =
			"\x10\xFFFF";
		private const string DFA228_minS =
			"\x1\x4\x5\xFFFF\x1\x4\x1\xFFFF\x2\x4\x6\xFFFF";
		private const string DFA228_maxS =
			"\x1\xCA\x5\xFFFF\x1\xCA\x1\xFFFF\x2\xCA\x6\xFFFF";
		private const string DFA228_acceptS =
			"\x1\xFFFF\x1\x1\x1\x2\x1\x3\x1\x4\x1\x5\x1\xFFFF\x1\x7\x2\xFFFF\x1\x8"+
			"\x1\x9\x1\xA\x1\xB\x1\x6\x1\xC";
		private const string DFA228_specialS =
			"\x10\xFFFF}>";
		private static readonly string[] DFA228_transitionS =
			{
				"\x1\x8\xE\xFFFF\x1\xB\x1\xFFFF\x4\x9\x28\xFFFF\x1\x9\x1\xFFFF\x1\x3"+
				"\xD\xFFFF\x1\x1\x1\x6\x10\xFFFF\x1\xC\x20\xFFFF\x2\x9\x1\xFFFF\xE\x9"+
				"\x1\x2\x3\x9\x1\xFFFF\x1\x9\x1\x5\x4\x9\x9\x7\x1\xA\x1\x9\x1\xFFFF\x1"+
				"\x4\x1\xFFFF\x2\xD\x1\xFFFF\x2\x9\x10\xFFFF\x1\x9\x6\x7\x1\x9",
				"",
				"",
				"",
				"",
				"",
				"\xA\xE\x7\xFFFF\x4\xE\x28\xFFFF\x1\xE\x24\xFFFF\x1\x7\x1D\xFFFF\x2"+
				"\xE\x1\xFFFF\xE\xE\x1\xFFFF\x3\xE\x1\xFFFF\x1\xE\x1\xFFFF\xD\xE\x1\xFFFF"+
				"\x1\xE\x6\xFFFF\x2\xE\x10\xFFFF\x8\xE",
				"",
				"\xB\x7\x6\xFFFF\x4\x7\x28\xFFFF\x1\x7\x11\xFFFF\x1\x7\x1\xFFFF\x1"+
				"\x7\x2\xFFFF\x1\x7\x1\xFFFF\x1\xF\xA\xFFFF\x3\x7\x1C\xFFFF\x2\x7\x1"+
				"\xFFFF\xE\x7\x1\xFFFF\x3\x7\x1\xFFFF\x1\x7\x1\xFFFF\xD\x7\x1\xFFFF\x1"+
				"\x7\x2\xFFFF\x1\x7\x3\xFFFF\x2\x7\x10\xFFFF\x8\x7",
				"\xB\x7\x6\xFFFF\x4\x7\x28\xFFFF\x1\x7\x11\xFFFF\x1\x7\x1\xFFFF\x1"+
				"\x7\x2\xFFFF\x1\x7\x1\xFFFF\x1\xF\xA\xFFFF\x3\x7\x1C\xFFFF\x2\x7\x1"+
				"\xFFFF\xE\x7\x1\xFFFF\x3\x7\x1\xFFFF\x1\x7\x1\xFFFF\xD\x7\x1\xFFFF\x1"+
				"\x7\x2\xFFFF\x1\x7\x3\xFFFF\x2\x7\x10\xFFFF\x8\x7",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA228_eot = DFA.UnpackEncodedString(DFA228_eotS);
		private static readonly short[] DFA228_eof = DFA.UnpackEncodedString(DFA228_eofS);
		private static readonly char[] DFA228_min = DFA.UnpackEncodedStringToUnsignedChars(DFA228_minS);
		private static readonly char[] DFA228_max = DFA.UnpackEncodedStringToUnsignedChars(DFA228_maxS);
		private static readonly short[] DFA228_accept = DFA.UnpackEncodedString(DFA228_acceptS);
		private static readonly short[] DFA228_special = DFA.UnpackEncodedString(DFA228_specialS);
		private static readonly short[][] DFA228_transition;

		static DFA228()
		{
			int numStates = DFA228_transitionS.Length;
			DFA228_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA228_transition[i] = DFA.UnpackEncodedString(DFA228_transitionS[i]);
			}
		}

		public DFA228( BaseRecognizer recognizer )
		{
			this.recognizer = recognizer;
			this.decisionNumber = 228;
			this.eot = DFA228_eot;
			this.eof = DFA228_eof;
			this.min = DFA228_min;
			this.max = DFA228_max;
			this.accept = DFA228_accept;
			this.special = DFA228_special;
			this.transition = DFA228_transition;
		}

		public override string Description { get { return "768:2: ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | class_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration )"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private class DFA227 : DFA
	{
		private const string DFA227_eotS =
			"\xB\xFFFF";
		private const string DFA227_eofS =
			"\xB\xFFFF";
		private const string DFA227_minS =
			"\x1\x4\x4\x0\x6\xFFFF";
		private const string DFA227_maxS =
			"\x1\xCA\x4\x0\x6\xFFFF";
		private const string DFA227_acceptS =
			"\x5\xFFFF\x1\x4\x1\x6\x1\x1\x1\x2\x1\x3\x1\x5";
		private const string DFA227_specialS =
			"\x1\xFFFF\x1\x0\x1\x1\x1\x2\x1\x3\x6\xFFFF}>";
		private static readonly string[] DFA227_transitionS =
			{
				"\x1\x2\x9\x4\x7\xFFFF\x4\x3\x28\xFFFF\x1\x3\x11\xFFFF\x1\x5\x30\xFFFF"+
				"\x2\x3\x1\xFFFF\xE\x3\x1\xFFFF\x3\x3\x1\xFFFF\x1\x3\x1\xFFFF\x4\x3\x9"+
				"\x1\x1\xFFFF\x1\x3\x2\xFFFF\x1\x6\x3\xFFFF\x2\x3\x10\xFFFF\x1\x3\x6"+
				"\x1\x1\x3",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA227_eot = DFA.UnpackEncodedString(DFA227_eotS);
		private static readonly short[] DFA227_eof = DFA.UnpackEncodedString(DFA227_eofS);
		private static readonly char[] DFA227_min = DFA.UnpackEncodedStringToUnsignedChars(DFA227_minS);
		private static readonly char[] DFA227_max = DFA.UnpackEncodedStringToUnsignedChars(DFA227_maxS);
		private static readonly short[] DFA227_accept = DFA.UnpackEncodedString(DFA227_acceptS);
		private static readonly short[] DFA227_special = DFA.UnpackEncodedString(DFA227_specialS);
		private static readonly short[][] DFA227_transition;

		static DFA227()
		{
			int numStates = DFA227_transitionS.Length;
			DFA227_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA227_transition[i] = DFA.UnpackEncodedString(DFA227_transitionS[i]);
			}
		}

		public DFA227( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 227;
			this.eot = DFA227_eot;
			this.eof = DFA227_eof;
			this.min = DFA227_min;
			this.max = DFA227_max;
			this.accept = DFA227_accept;
			this.special = DFA227_special;
			this.transition = DFA227_transition;
		}

		public override string Description { get { return "778:9: ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition227(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA227_1 = input.LA(1);


				int index227_1 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred28_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred29_cs_fragment)) ) {s = 8;}


				input.Seek(index227_1);
				if ( s>=0 ) return s;
				break;
			case 1:
				int LA227_2 = input.LA(1);


				int index227_2 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred28_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred29_cs_fragment)) ) {s = 8;}

				else if ( (EvaluatePredicate(synpred30_cs_fragment)) ) {s = 9;}

				else if ( (true) ) {s = 10;}


				input.Seek(index227_2);
				if ( s>=0 ) return s;
				break;
			case 2:
				int LA227_3 = input.LA(1);


				int index227_3 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred28_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred29_cs_fragment)) ) {s = 8;}

				else if ( (EvaluatePredicate(synpred30_cs_fragment)) ) {s = 9;}

				else if ( (true) ) {s = 10;}


				input.Seek(index227_3);
				if ( s>=0 ) return s;
				break;
			case 3:
				int LA227_4 = input.LA(1);


				int index227_4 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred28_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred29_cs_fragment)) ) {s = 8;}


				input.Seek(index227_4);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 227, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA231 : DFA
	{
		private const string DFA231_eotS =
			"\x10\xFFFF";
		private const string DFA231_eofS =
			"\x10\xFFFF";
		private const string DFA231_minS =
			"\x1\x11\x7\xFFFF\x1\x11\x7\xFFFF";
		private const string DFA231_maxS =
			"\x1\x7F\x7\xFFFF\x1\x5A\x7\xFFFF";
		private const string DFA231_acceptS =
			"\x1\xFFFF\x1\x1\x1\x2\x1\x3\x1\x4\x1\x5\x1\x6\x1\x7\x1\xFFFF\x1\x9\x1"+
			"\xA\x1\xC\x1\xD\x1\xE\x1\x8\x1\xB";
		private const string DFA231_specialS =
			"\x10\xFFFF}>";
		private static readonly string[] DFA231_transitionS =
			{
				"\x1\x8\x53\xFFFF\x1\xB\x1\x1\xD\xFFFF\x1\xC\x1\x4\x1\x2\x1\x3\x1\x7"+
				"\x1\xD\x2\xFFFF\x1\x9\x1\xA\x1\x6\x1\x5",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"\x1\xE\x48\xFFFF\x1\xF",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA231_eot = DFA.UnpackEncodedString(DFA231_eotS);
		private static readonly short[] DFA231_eof = DFA.UnpackEncodedString(DFA231_eofS);
		private static readonly char[] DFA231_min = DFA.UnpackEncodedStringToUnsignedChars(DFA231_minS);
		private static readonly char[] DFA231_max = DFA.UnpackEncodedStringToUnsignedChars(DFA231_maxS);
		private static readonly short[] DFA231_accept = DFA.UnpackEncodedString(DFA231_acceptS);
		private static readonly short[] DFA231_special = DFA.UnpackEncodedString(DFA231_specialS);
		private static readonly short[][] DFA231_transition;

		static DFA231()
		{
			int numStates = DFA231_transitionS.Length;
			DFA231_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA231_transition[i] = DFA.UnpackEncodedString(DFA231_transitionS[i]);
			}
		}

		public DFA231( BaseRecognizer recognizer )
		{
			this.recognizer = recognizer;
			this.decisionNumber = 231;
			this.eot = DFA231_eot;
			this.eof = DFA231_eof;
			this.min = DFA231_min;
			this.max = DFA231_max;
			this.accept = DFA231_accept;
			this.special = DFA231_special;
			this.transition = DFA231_transition;
		}

		public override string Description { get { return "818:8: public overloadable_binary_operator : ( '*' | '/' | '%' | '&' | '|' | '^' | '<<' | '>' '>' | '==' | '!=' | '>' | '<' | '>=' | '<=' );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private class DFA239 : DFA
	{
		private const string DFA239_eotS =
			"\x30\xFFFF";
		private const string DFA239_eofS =
			"\x30\xFFFF";
		private const string DFA239_minS =
			"\x1\x4\x5\x0\x14\xFFFF\x1\x0\x13\xFFFF\x1\x0\x1\xFFFF";
		private const string DFA239_maxS =
			"\x1\xCA\x5\x0\x14\xFFFF\x1\x0\x13\xFFFF\x1\x0\x1\xFFFF";
		private const string DFA239_acceptS =
			"\x6\xFFFF\x2\x1\x1\x3\x26\xFFFF\x1\x2";
		private const string DFA239_specialS =
			"\x1\x0\x1\x1\x1\x2\x1\x3\x1\x4\x1\x5\x14\xFFFF\x1\x6\x13\xFFFF\x1\x7"+
			"\x1\xFFFF}>";
		private static readonly string[] DFA239_transitionS =
			{
				"\x1\x4\x9\x8\x2\xFFFF\x1\x8\x1\xFFFF\x1\x8\x1\xFFFF\x1\x8\x4\x2E\x1"+
				"\x8\x24\xFFFF\x1\x8\x2\xFFFF\x1\x2E\x2\xFFFF\x1\x8\x4\xFFFF\x1\x8\x7"+
				"\xFFFF\x1\x7\x1\x6\x2\x8\x1\xFFFF\x2\x8\x2\xFFFF\x1\x8\x4\xFFFF\x6\x8"+
				"\x1\xFFFF\x1\x8\x1\xFFFF\x3\x8\xA\xFFFF\x1\x8\xE\xFFFF\x1\x2E\x1\x1A"+
				"\x1\xFFFF\xE\x2E\x1\xFFFF\x3\x2E\x1\x8\x1\x2E\x1\xFFFF\x4\x2E\x9\x3"+
				"\x1\xFFFF\x1\x2E\x5\xFFFF\x1\x8\x1\x1\x1\x2\x2\xFFFF\x1\x8\x1\xFFFF"+
				"\x9\x8\x2\xFFFF\x1\x8\x1\x5\x6\x3\x1\x2E",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"\x1\xFFFF",
				""
			};

		private static readonly short[] DFA239_eot = DFA.UnpackEncodedString(DFA239_eotS);
		private static readonly short[] DFA239_eof = DFA.UnpackEncodedString(DFA239_eofS);
		private static readonly char[] DFA239_min = DFA.UnpackEncodedStringToUnsignedChars(DFA239_minS);
		private static readonly char[] DFA239_max = DFA.UnpackEncodedStringToUnsignedChars(DFA239_maxS);
		private static readonly short[] DFA239_accept = DFA.UnpackEncodedString(DFA239_acceptS);
		private static readonly short[] DFA239_special = DFA.UnpackEncodedString(DFA239_specialS);
		private static readonly short[][] DFA239_transition;

		static DFA239()
		{
			int numStates = DFA239_transitionS.Length;
			DFA239_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA239_transition[i] = DFA.UnpackEncodedString(DFA239_transitionS[i]);
			}
		}

		public DFA239( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 239;
			this.eot = DFA239_eot;
			this.eof = DFA239_eof;
			this.min = DFA239_min;
			this.max = DFA239_max;
			this.accept = DFA239_accept;
			this.special = DFA239_special;
			this.transition = DFA239_transition;
		}

		public override string Description { get { return "868:8: public statement : ( ( declaration_statement )=> declaration_statement | ( identifier ':' )=> labeled_statement | embedded_statement );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition239(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA239_0 = input.LA(1);


				int index239_0 = input.Index;
				input.Rewind();
				s = -1;
				if ( (LA239_0==177) ) {s = 1;}

				else if ( (LA239_0==178) ) {s = 2;}

				else if ( ((LA239_0>=160 && LA239_0<=168)||(LA239_0>=196 && LA239_0<=201)) ) {s = 3;}

				else if ( (LA239_0==IDENTIFIER) ) {s = 4;}

				else if ( (LA239_0==195) ) {s = 5;}

				else if ( (LA239_0==82) && (EvaluatePredicate(synpred33_cs_fragment))) {s = 6;}

				else if ( (LA239_0==81) && (EvaluatePredicate(synpred33_cs_fragment))) {s = 7;}

				else if ( ((LA239_0>=Real_literal && LA239_0<=NULL)||LA239_0==MINUS||LA239_0==USING||LA239_0==IF||LA239_0==SEMI||LA239_0==62||LA239_0==68||LA239_0==73||(LA239_0>=83 && LA239_0<=84)||(LA239_0>=86 && LA239_0<=87)||LA239_0==90||(LA239_0>=95 && LA239_0<=100)||LA239_0==102||(LA239_0>=104 && LA239_0<=106)||LA239_0==117||LA239_0==153||LA239_0==176||LA239_0==181||(LA239_0>=183 && LA239_0<=191)||LA239_0==194) ) {s = 8;}

				else if ( (LA239_0==133) ) {s = 26;}

				else if ( ((LA239_0>=ELIF && LA239_0<=UNDEF)||LA239_0==65||LA239_0==132||(LA239_0>=135 && LA239_0<=148)||(LA239_0>=150 && LA239_0<=152)||LA239_0==154||(LA239_0>=156 && LA239_0<=159)||LA239_0==170||LA239_0==202) ) {s = 46;}


				input.Seek(index239_0);
				if ( s>=0 ) return s;
				break;
			case 1:
				int LA239_1 = input.LA(1);


				int index239_1 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred33_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred34_cs_fragment)) ) {s = 47;}

				else if ( (true) ) {s = 8;}


				input.Seek(index239_1);
				if ( s>=0 ) return s;
				break;
			case 2:
				int LA239_2 = input.LA(1);


				int index239_2 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred33_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred34_cs_fragment)) ) {s = 47;}

				else if ( (true) ) {s = 8;}


				input.Seek(index239_2);
				if ( s>=0 ) return s;
				break;
			case 3:
				int LA239_3 = input.LA(1);


				int index239_3 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred33_cs_fragment)) ) {s = 7;}

				else if ( (true) ) {s = 8;}


				input.Seek(index239_3);
				if ( s>=0 ) return s;
				break;
			case 4:
				int LA239_4 = input.LA(1);


				int index239_4 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred33_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred34_cs_fragment)) ) {s = 47;}

				else if ( (true) ) {s = 8;}


				input.Seek(index239_4);
				if ( s>=0 ) return s;
				break;
			case 5:
				int LA239_5 = input.LA(1);


				int index239_5 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred33_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred34_cs_fragment)) ) {s = 47;}

				else if ( (true) ) {s = 8;}


				input.Seek(index239_5);
				if ( s>=0 ) return s;
				break;
			case 6:
				int LA239_26 = input.LA(1);


				int index239_26 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred33_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred34_cs_fragment)) ) {s = 47;}

				else if ( (true) ) {s = 8;}


				input.Seek(index239_26);
				if ( s>=0 ) return s;
				break;
			case 7:
				int LA239_46 = input.LA(1);


				int index239_46 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred33_cs_fragment)) ) {s = 7;}

				else if ( (EvaluatePredicate(synpred34_cs_fragment)) ) {s = 47;}

				else if ( (true) ) {s = 8;}


				input.Seek(index239_46);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 239, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA240 : DFA
	{
		private const string DFA240_eotS =
			"\x11\xFFFF";
		private const string DFA240_eofS =
			"\x11\xFFFF";
		private const string DFA240_minS =
			"\x1\x4\x5\xFFFF\x2\x19\x2\xFFFF\x1\xE\x6\xFFFF";
		private const string DFA240_maxS =
			"\x1\xCA\x5\xFFFF\x2\x5A\x2\xFFFF\x1\xBB\x6\xFFFF";
		private const string DFA240_acceptS =
			"\x1\xFFFF\x1\x1\x1\x2\x1\x3\x1\x4\x1\x5\x2\xFFFF\x1\x8\x1\x9\x1\xFFFF"+
			"\x1\xB\x1\xC\x1\xD\x1\x6\x1\x7\x1\xA";
		private const string DFA240_specialS =
			"\x11\xFFFF}>";
		private static readonly string[] DFA240_transitionS =
			{
				"\xA\xD\x2\xFFFF\x1\xD\x1\xFFFF\x1\x9\x1\xFFFF\x1\x2\x4\xD\x1\x1\x24"+
				"\xFFFF\x1\x1\x2\xFFFF\x1\xD\x2\xFFFF\x1\xD\x4\xFFFF\x1\xB\x9\xFFFF\x2"+
				"\xD\x1\xFFFF\x2\xD\x2\xFFFF\x1\xD\x4\xFFFF\x1\xD\x1\x6\x1\x7\x3\xD\x1"+
				"\xFFFF\x1\xD\x1\xFFFF\x3\xD\xA\xFFFF\x1\xD\xE\xFFFF\x2\xD\x1\xFFFF\xE"+
				"\xD\x1\xFFFF\x3\xD\x1\x4\x1\xD\x1\xFFFF\xD\xD\x1\xFFFF\x1\xD\x5\xFFFF"+
				"\x1\xC\x2\xD\x2\xFFFF\x1\x2\x1\xFFFF\x4\x3\x4\x4\x1\x5\x2\xFFFF\x1\x8"+
				"\x1\xA\x7\xD",
				"",
				"",
				"",
				"",
				"",
				"\x1\xE\x24\xFFFF\x1\xE\x1B\xFFFF\x1\xD",
				"\x1\xF\x24\xFFFF\x1\xF\x1B\xFFFF\x1\xD",
				"",
				"",
				"\x4\xD\x7\xFFFF\x1\xD\x28\xFFFF\x1\xD\x12\xFFFF\x4\xD\x1\xFFFF\x2"+
				"\xD\x9\xFFFF\x4\xD\x2\xFFFF\x19\xD\x15\xFFFF\x1\x10\x21\xFFFF\x1\x10",
				"",
				"",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA240_eot = DFA.UnpackEncodedString(DFA240_eotS);
		private static readonly short[] DFA240_eof = DFA.UnpackEncodedString(DFA240_eofS);
		private static readonly char[] DFA240_min = DFA.UnpackEncodedStringToUnsignedChars(DFA240_minS);
		private static readonly char[] DFA240_max = DFA.UnpackEncodedStringToUnsignedChars(DFA240_maxS);
		private static readonly short[] DFA240_accept = DFA.UnpackEncodedString(DFA240_acceptS);
		private static readonly short[] DFA240_special = DFA.UnpackEncodedString(DFA240_specialS);
		private static readonly short[][] DFA240_transition;

		static DFA240()
		{
			int numStates = DFA240_transitionS.Length;
			DFA240_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA240_transition[i] = DFA.UnpackEncodedString(DFA240_transitionS[i]);
			}
		}

		public DFA240( BaseRecognizer recognizer )
		{
			this.recognizer = recognizer;
			this.decisionNumber = 240;
			this.eot = DFA240_eot;
			this.eof = DFA240_eof;
			this.min = DFA240_min;
			this.max = DFA240_max;
			this.accept = DFA240_accept;
			this.special = DFA240_special;
			this.transition = DFA240_transition;
		}

		public override string Description { get { return "873:8: public embedded_statement : ( block | selection_statement | iteration_statement | jump_statement | try_statement | checked_statement | unchecked_statement | lock_statement | using_statement | yield_statement | unsafe_statement | fixed_statement | expression_statement );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private class DFA257 : DFA
	{
		private const string DFA257_eotS =
			"\x1B\xFFFF";
		private const string DFA257_eofS =
			"\x1B\xFFFF";
		private const string DFA257_minS =
			"\x1\x4\x5\x0\x14\xFFFF\x1\x0";
		private const string DFA257_maxS =
			"\x1\xCA\x5\x0\x14\xFFFF\x1\x0";
		private const string DFA257_acceptS =
			"\x6\xFFFF\x1\x1\x1\x2\x13\xFFFF";
		private const string DFA257_specialS =
			"\x1\x0\x1\x1\x1\x2\x1\x3\x1\x4\x1\x5\x14\xFFFF\x1\x6}>";
		private static readonly string[] DFA257_transitionS =
			{
				"\x1\x4\x9\x7\x2\xFFFF\x1\x7\x4\xFFFF\x4\x1A\x28\xFFFF\x1\x1A\x2\xFFFF"+
				"\x1\x7\xD\xFFFF\x1\x6\x2\x7\x1\xFFFF\x2\x7\x2\xFFFF\x1\x7\x4\xFFFF\x6"+
				"\x7\x1\xFFFF\x1\x7\x1\xFFFF\x3\x7\xA\xFFFF\x1\x7\xE\xFFFF\x1\x1A\x1"+
				"\x5\x1\xFFFF\xE\x1A\x1\xFFFF\x3\x1A\x1\xFFFF\x1\x1A\x1\xFFFF\x4\x1A"+
				"\x9\x3\x1\xFFFF\x1\x1A\x6\xFFFF\x1\x1\x1\x2\x10\xFFFF\x1\x1A\x6\x3\x1"+
				"\x1A",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"\x1\xFFFF"
			};

		private static readonly short[] DFA257_eot = DFA.UnpackEncodedString(DFA257_eotS);
		private static readonly short[] DFA257_eof = DFA.UnpackEncodedString(DFA257_eofS);
		private static readonly char[] DFA257_min = DFA.UnpackEncodedStringToUnsignedChars(DFA257_minS);
		private static readonly char[] DFA257_max = DFA.UnpackEncodedStringToUnsignedChars(DFA257_maxS);
		private static readonly short[] DFA257_accept = DFA.UnpackEncodedString(DFA257_acceptS);
		private static readonly short[] DFA257_special = DFA.UnpackEncodedString(DFA257_specialS);
		private static readonly short[][] DFA257_transition;

		static DFA257()
		{
			int numStates = DFA257_transitionS.Length;
			DFA257_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA257_transition[i] = DFA.UnpackEncodedString(DFA257_transitionS[i]);
			}
		}

		public DFA257( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 257;
			this.eot = DFA257_eot;
			this.eof = DFA257_eof;
			this.min = DFA257_min;
			this.max = DFA257_max;
			this.accept = DFA257_accept;
			this.special = DFA257_special;
			this.transition = DFA257_transition;
		}

		public override string Description { get { return "962:8: public for_initializer : ( ( local_variable_declaration )=> local_variable_declaration | statement_expression_list );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition257(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA257_0 = input.LA(1);


				int index257_0 = input.Index;
				input.Rewind();
				s = -1;
				if ( (LA257_0==177) ) {s = 1;}

				else if ( (LA257_0==178) ) {s = 2;}

				else if ( ((LA257_0>=160 && LA257_0<=168)||(LA257_0>=196 && LA257_0<=201)) ) {s = 3;}

				else if ( (LA257_0==IDENTIFIER) ) {s = 4;}

				else if ( (LA257_0==133) ) {s = 5;}

				else if ( (LA257_0==82) && (EvaluatePredicate(synpred38_cs_fragment))) {s = 6;}

				else if ( ((LA257_0>=Real_literal && LA257_0<=NULL)||LA257_0==MINUS||LA257_0==68||(LA257_0>=83 && LA257_0<=84)||(LA257_0>=86 && LA257_0<=87)||LA257_0==90||(LA257_0>=95 && LA257_0<=100)||LA257_0==102||(LA257_0>=104 && LA257_0<=106)||LA257_0==117) ) {s = 7;}

				else if ( ((LA257_0>=ELIF && LA257_0<=UNDEF)||LA257_0==65||LA257_0==132||(LA257_0>=135 && LA257_0<=148)||(LA257_0>=150 && LA257_0<=152)||LA257_0==154||(LA257_0>=156 && LA257_0<=159)||LA257_0==170||LA257_0==195||LA257_0==202) ) {s = 26;}


				input.Seek(index257_0);
				if ( s>=0 ) return s;
				break;
			case 1:
				int LA257_1 = input.LA(1);


				int index257_1 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred38_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index257_1);
				if ( s>=0 ) return s;
				break;
			case 2:
				int LA257_2 = input.LA(1);


				int index257_2 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred38_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index257_2);
				if ( s>=0 ) return s;
				break;
			case 3:
				int LA257_3 = input.LA(1);


				int index257_3 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred38_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index257_3);
				if ( s>=0 ) return s;
				break;
			case 4:
				int LA257_4 = input.LA(1);


				int index257_4 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred38_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index257_4);
				if ( s>=0 ) return s;
				break;
			case 5:
				int LA257_5 = input.LA(1);


				int index257_5 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred38_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index257_5);
				if ( s>=0 ) return s;
				break;
			case 6:
				int LA257_26 = input.LA(1);


				int index257_26 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred38_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index257_26);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 257, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
	private class DFA269 : DFA
	{
		private const string DFA269_eotS =
			"\x1B\xFFFF";
		private const string DFA269_eofS =
			"\x1B\xFFFF";
		private const string DFA269_minS =
			"\x1\x4\x5\x0\x14\xFFFF\x1\x0";
		private const string DFA269_maxS =
			"\x1\xCA\x5\x0\x14\xFFFF\x1\x0";
		private const string DFA269_acceptS =
			"\x6\xFFFF\x1\x1\x1\x2\x13\xFFFF";
		private const string DFA269_specialS =
			"\x1\x0\x1\x1\x1\x2\x1\x3\x1\x4\x1\x5\x14\xFFFF\x1\x6}>";
		private static readonly string[] DFA269_transitionS =
			{
				"\x1\x4\x9\x7\x2\xFFFF\x1\x7\x4\xFFFF\x4\x1A\x28\xFFFF\x1\x1A\x2\xFFFF"+
				"\x1\x7\xD\xFFFF\x1\x6\x2\x7\x1\xFFFF\x2\x7\x2\xFFFF\x1\x7\x4\xFFFF\x6"+
				"\x7\x1\xFFFF\x1\x7\x1\xFFFF\x3\x7\xA\xFFFF\x1\x7\xE\xFFFF\x1\x1A\x1"+
				"\x5\x1\xFFFF\xE\x1A\x1\xFFFF\x3\x1A\x1\xFFFF\x1\x1A\x1\xFFFF\x4\x1A"+
				"\x9\x3\x1\xFFFF\x1\x1A\x6\xFFFF\x1\x1\x1\x2\x10\xFFFF\x1\x1A\x6\x3\x1"+
				"\x1A",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"\x1\xFFFF",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"\x1\xFFFF"
			};

		private static readonly short[] DFA269_eot = DFA.UnpackEncodedString(DFA269_eotS);
		private static readonly short[] DFA269_eof = DFA.UnpackEncodedString(DFA269_eofS);
		private static readonly char[] DFA269_min = DFA.UnpackEncodedStringToUnsignedChars(DFA269_minS);
		private static readonly char[] DFA269_max = DFA.UnpackEncodedStringToUnsignedChars(DFA269_maxS);
		private static readonly short[] DFA269_accept = DFA.UnpackEncodedString(DFA269_acceptS);
		private static readonly short[] DFA269_special = DFA.UnpackEncodedString(DFA269_specialS);
		private static readonly short[][] DFA269_transition;

		static DFA269()
		{
			int numStates = DFA269_transitionS.Length;
			DFA269_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA269_transition[i] = DFA.UnpackEncodedString(DFA269_transitionS[i]);
			}
		}

		public DFA269( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )
			: base(specialStateTransition)
		{
			this.recognizer = recognizer;
			this.decisionNumber = 269;
			this.eot = DFA269_eot;
			this.eof = DFA269_eof;
			this.min = DFA269_min;
			this.max = DFA269_max;
			this.accept = DFA269_accept;
			this.special = DFA269_special;
			this.transition = DFA269_transition;
		}

		public override string Description { get { return "1014:8: public resource_acquisition : ( ( local_variable_declaration )=> local_variable_declaration | expression );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private int SpecialStateTransition269(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA269_0 = input.LA(1);


				int index269_0 = input.Index;
				input.Rewind();
				s = -1;
				if ( (LA269_0==177) ) {s = 1;}

				else if ( (LA269_0==178) ) {s = 2;}

				else if ( ((LA269_0>=160 && LA269_0<=168)||(LA269_0>=196 && LA269_0<=201)) ) {s = 3;}

				else if ( (LA269_0==IDENTIFIER) ) {s = 4;}

				else if ( (LA269_0==133) ) {s = 5;}

				else if ( (LA269_0==82) && (EvaluatePredicate(synpred39_cs_fragment))) {s = 6;}

				else if ( ((LA269_0>=Real_literal && LA269_0<=NULL)||LA269_0==MINUS||LA269_0==68||(LA269_0>=83 && LA269_0<=84)||(LA269_0>=86 && LA269_0<=87)||LA269_0==90||(LA269_0>=95 && LA269_0<=100)||LA269_0==102||(LA269_0>=104 && LA269_0<=106)||LA269_0==117) ) {s = 7;}

				else if ( ((LA269_0>=ELIF && LA269_0<=UNDEF)||LA269_0==65||LA269_0==132||(LA269_0>=135 && LA269_0<=148)||(LA269_0>=150 && LA269_0<=152)||LA269_0==154||(LA269_0>=156 && LA269_0<=159)||LA269_0==170||LA269_0==195||LA269_0==202) ) {s = 26;}


				input.Seek(index269_0);
				if ( s>=0 ) return s;
				break;
			case 1:
				int LA269_1 = input.LA(1);


				int index269_1 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred39_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index269_1);
				if ( s>=0 ) return s;
				break;
			case 2:
				int LA269_2 = input.LA(1);


				int index269_2 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred39_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index269_2);
				if ( s>=0 ) return s;
				break;
			case 3:
				int LA269_3 = input.LA(1);


				int index269_3 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred39_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index269_3);
				if ( s>=0 ) return s;
				break;
			case 4:
				int LA269_4 = input.LA(1);


				int index269_4 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred39_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index269_4);
				if ( s>=0 ) return s;
				break;
			case 5:
				int LA269_5 = input.LA(1);


				int index269_5 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred39_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index269_5);
				if ( s>=0 ) return s;
				break;
			case 6:
				int LA269_26 = input.LA(1);


				int index269_26 = input.Index;
				input.Rewind();
				s = -1;
				if ( (EvaluatePredicate(synpred39_cs_fragment)) ) {s = 6;}

				else if ( (true) ) {s = 7;}


				input.Seek(index269_26);
				if ( s>=0 ) return s;
				break;
		}
		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 269, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}

	#endregion DFA

	#region Follow sets
	private static class Follow
	{
		public static readonly BitSet _namespace_body_in_compilation_unit72 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _61_in_namespace_declaration83 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _qualified_identifier_in_namespace_declaration87 = new BitSet(new ulong[]{0x4000000000000000UL});
		public static readonly BitSet _namespace_block_in_namespace_declaration91 = new BitSet(new ulong[]{0x2000002UL});
		public static readonly BitSet _SEMI_in_namespace_declaration95 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _62_in_namespace_block106 = new BitSet(new ulong[]{0xA0000000000C0000UL,0x80101FFF9UL,0x120008000000UL});
		public static readonly BitSet _namespace_body_in_namespace_block110 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_namespace_block115 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _extern_alias_directives_in_namespace_body124 = new BitSet(new ulong[]{0x20000000000C0002UL,0x80101FFF9UL,0x120008000000UL});
		public static readonly BitSet _using_directives_in_namespace_body129 = new BitSet(new ulong[]{0x2000000000080002UL,0x80101FFF9UL,0x120008000000UL});
		public static readonly BitSet _global_attributes_in_namespace_body134 = new BitSet(new ulong[]{0x2000000000080002UL,0x80101FFF9UL,0x120008000000UL});
		public static readonly BitSet _namespace_member_declarations_in_namespace_body139 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _extern_alias_directive_in_extern_alias_directives150 = new BitSet(new ulong[]{0x2UL,0x1UL});
		public static readonly BitSet _64_in_extern_alias_directive161 = new BitSet(new ulong[]{0x0UL,0x2UL});
		public static readonly BitSet _65_in_extern_alias_directive165 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_extern_alias_directive169 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_extern_alias_directive172 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _using_directive_in_using_directives182 = new BitSet(new ulong[]{0x40002UL});
		public static readonly BitSet _using_alias_directive_in_using_directive194 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _using_namespace_directive_in_using_directive199 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _USING_in_using_alias_directive210 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_using_alias_directive214 = new BitSet(new ulong[]{0x0UL,0x4UL});
		public static readonly BitSet _66_in_using_alias_directive218 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _namespace_or_type_name_in_using_alias_directive222 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_using_alias_directive226 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _USING_in_using_namespace_directive236 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _namespace_name_in_using_namespace_directive240 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_using_namespace_directive244 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _namespace_member_declaration_in_namespace_member_declarations254 = new BitSet(new ulong[]{0x2000000000080002UL,0x80101FFF9UL,0x120008000000UL});
		public static readonly BitSet _namespace_declaration_in_namespace_member_declaration265 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _attributes_in_namespace_member_declaration270 = new BitSet(new ulong[]{0x2000000000080000UL,0x80101FFF9UL,0x120008000000UL});
		public static readonly BitSet _modifiers_in_namespace_member_declaration275 = new BitSet(new ulong[]{0x2000000000080000UL,0x80101FFF9UL,0x120008000000UL});
		public static readonly BitSet _type_declaration_in_namespace_member_declaration280 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _67_in_type_declaration296 = new BitSet(new ulong[]{0x0UL,0x0UL,0x120008000000UL});
		public static readonly BitSet _class_declaration_in_type_declaration301 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _struct_declaration_in_type_declaration313 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _interface_declaration_in_type_declaration325 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _class_declaration_in_type_declaration331 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _struct_declaration_in_type_declaration336 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _interface_declaration_in_type_declaration341 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _enum_declaration_in_type_declaration346 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _delegate_declaration_in_type_declaration351 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_qualified_identifier362 = new BitSet(new ulong[]{0x4002UL});
		public static readonly BitSet _DOT_in_qualified_identifier365 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_qualified_identifier367 = new BitSet(new ulong[]{0x4002UL});
		public static readonly BitSet _namespace_or_type_name_in_namespace_name378 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _modifier_in_modifiers389 = new BitSet(new ulong[]{0x2UL,0x1FFF1UL});
		public static readonly BitSet _set_in_modifier0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _attributes_in_class_member_declaration465 = new BitSet(new ulong[]{0x2000000001E80010UL,0x4080107FFFBUL,0x6D7FFFDFFFFB0UL,0x7F8UL});
		public static readonly BitSet _modifiers_in_class_member_declaration471 = new BitSet(new ulong[]{0x2000000001E80010UL,0x4080107FFFBUL,0x6D7FFFDFFFFB0UL,0x7F8UL});
		public static readonly BitSet _81_in_class_member_declaration477 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_class_member_declaration481 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _constant_declarators_in_class_member_declaration485 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_class_member_declaration489 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _event_declaration_in_class_member_declaration494 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _67_in_class_member_declaration501 = new BitSet(new ulong[]{0x0UL,0x40000UL,0x120008000000UL});
		public static readonly BitSet _82_in_class_member_declaration504 = new BitSet(new ulong[]{0x1E03FF0UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _method_declaration_in_class_member_declaration506 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _interface_declaration_in_class_member_declaration517 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _class_declaration_in_class_member_declaration528 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _struct_declaration_in_class_member_declaration539 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _interface_declaration_in_class_member_declaration545 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _82_in_class_member_declaration551 = new BitSet(new ulong[]{0x1E03FF0UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _method_declaration_in_class_member_declaration555 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_class_member_declaration560 = new BitSet(new ulong[]{0x1E03FF0UL,0x80002UL,0x625FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _method_declaration_in_class_member_declaration574 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _property_declaration_in_class_member_declaration593 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_name_in_class_member_declaration616 = new BitSet(new ulong[]{0x4000UL});
		public static readonly BitSet _DOT_in_class_member_declaration618 = new BitSet(new ulong[]{0x0UL,0x80000UL});
		public static readonly BitSet _indexer_declaration_in_class_member_declaration620 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _indexer_declaration_in_class_member_declaration629 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _field_declaration_in_class_member_declaration642 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _operator_declaration_in_class_member_declaration660 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _class_declaration_in_class_member_declaration678 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _struct_declaration_in_class_member_declaration685 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _enum_declaration_in_class_member_declaration691 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _delegate_declaration_in_class_member_declaration698 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _conversion_operator_declaration_in_class_member_declaration704 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _constructor_declaration_in_class_member_declaration709 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _destructor_declaration_in_class_member_declaration715 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _83_in_primary_expression743 = new BitSet(new ulong[]{0x0UL,0x1000000UL});
		public static readonly BitSet _brackets_in_primary_expression747 = new BitSet(new ulong[]{0xC002UL,0x5C00000UL});
		public static readonly BitSet _primary_expression_part_in_primary_expression751 = new BitSet(new ulong[]{0xC002UL,0x5C00000UL});
		public static readonly BitSet _84_in_primary_expression767 = new BitSet(new ulong[]{0x0UL,0x1000000UL});
		public static readonly BitSet _brackets_in_primary_expression771 = new BitSet(new ulong[]{0xC002UL,0x5C00000UL});
		public static readonly BitSet _primary_expression_part_in_primary_expression775 = new BitSet(new ulong[]{0xC002UL,0x5C00000UL});
		public static readonly BitSet _primary_expression_start_in_primary_expression781 = new BitSet(new ulong[]{0xC002UL,0x5C00000UL});
		public static readonly BitSet _primary_expression_part_in_primary_expression785 = new BitSet(new ulong[]{0xC002UL,0x5C00000UL});
		public static readonly BitSet _68_in_primary_expression791 = new BitSet(new ulong[]{0x4000000001E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _object_creation_expression_in_primary_expression819 = new BitSet(new ulong[]{0xC000UL,0x5C00000UL});
		public static readonly BitSet _primary_expression_part_in_primary_expression823 = new BitSet(new ulong[]{0xC002UL,0x5C00000UL});
		public static readonly BitSet _delegate_creation_expression_in_primary_expression851 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _object_creation_expression_in_primary_expression859 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _anonymous_object_creation_expression_in_primary_expression867 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _sizeof_expression_in_primary_expression880 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _checked_expression_in_primary_expression891 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _unchecked_expression_in_primary_expression910 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _default_value_expression_in_primary_expression927 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _anonymous_method_expression_in_primary_expression940 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _predefined_type_in_primary_expression_start955 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_primary_expression_start983 = new BitSet(new ulong[]{0x0UL,0x2000000000UL});
		public static readonly BitSet _generic_argument_list_in_primary_expression_start987 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_primary_expression_start992 = new BitSet(new ulong[]{0x2UL,0x200000UL});
		public static readonly BitSet _85_in_primary_expression_start995 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_primary_expression_start999 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _83_in_primary_expression_start1006 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _84_in_primary_expression_start1012 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _paren_expression_in_primary_expression_start1017 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _typeof_expression_in_primary_expression_start1022 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _literal_in_primary_expression_start1040 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _access_identifier_in_primary_expression_part1053 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _brackets_or_arguments_in_primary_expression_part1058 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _86_in_primary_expression_part1064 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _87_in_primary_expression_part1069 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _access_operator_in_access_identifier1079 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _type_or_generic_in_access_identifier1083 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_access_operator0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _brackets_in_brackets_or_arguments1109 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _arguments_in_brackets_or_arguments1113 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _88_in_brackets1123 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F86D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_list_in_brackets1127 = new BitSet(new ulong[]{0x0UL,0x2000000UL});
		public static readonly BitSet _89_in_brackets1132 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _90_in_paren_expression1144 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_paren_expression1148 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_paren_expression1152 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _90_in_arguments1163 = new BitSet(new ulong[]{0x5E13FF0UL,0x20075FE4D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _argument_list_in_arguments1167 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_arguments1172 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _argument_in_argument_list1183 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_argument_list1186 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075FE4D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _argument_in_argument_list1188 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _argument_name_in_argument1200 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075FE4D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _argument_value_in_argument1204 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _argument_value_in_argument1209 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_argument_name1218 = new BitSet(new ulong[]{0x0UL,0x10000000UL});
		public static readonly BitSet _92_in_argument_name1222 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_argument_value1232 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _ref_variable_reference_in_argument_value1238 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _93_in_argument_value1244 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _variable_reference_in_argument_value1248 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _94_in_ref_variable_reference1258 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _90_in_ref_variable_reference1280 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_ref_variable_reference1284 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_ref_variable_reference1288 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075FC4D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _ref_variable_reference_in_ref_variable_reference1293 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _variable_reference_in_ref_variable_reference1297 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _variable_reference_in_ref_variable_reference1333 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_variable_reference1345 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _rank_specifier_in_rank_specifiers1355 = new BitSet(new ulong[]{0x2UL,0x1000000UL});
		public static readonly BitSet _88_in_rank_specifier1375 = new BitSet(new ulong[]{0x0UL,0xA000000UL});
		public static readonly BitSet _dim_separators_in_rank_specifier1379 = new BitSet(new ulong[]{0x0UL,0x2000000UL});
		public static readonly BitSet _89_in_rank_specifier1384 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _91_in_dim_separators1395 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _type_name_in_delegate_creation_expression1410 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_delegate_creation_expression1414 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_name_in_delegate_creation_expression1418 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_delegate_creation_expression1422 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _anonymous_object_initializer_in_anonymous_object_creation_expression1435 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _62_in_anonymous_object_initializer1446 = new BitSet(new ulong[]{0x8000000001E03FF0UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _member_declarator_list_in_anonymous_object_initializer1451 = new BitSet(new ulong[]{0x8000000000000000UL,0x8000000UL});
		public static readonly BitSet _91_in_anonymous_object_initializer1455 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_anonymous_object_initializer1462 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_declarator_in_member_declarator_list1472 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_member_declarator_list1476 = new BitSet(new ulong[]{0x1E03FF0UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _member_declarator_in_member_declarator_list1478 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _qid_in_member_declarator1492 = new BitSet(new ulong[]{0x2UL,0x4UL});
		public static readonly BitSet _66_in_member_declarator1497 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_member_declarator1501 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _array_creation_expression_in_primary_or_array_creation_expression1519 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _primary_expression_in_primary_or_array_creation_expression1524 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _68_in_array_creation_expression1537 = new BitSet(new ulong[]{0x4000000001E00010UL,0x1040002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_array_creation_expression1545 = new BitSet(new ulong[]{0x4000000001E00010UL,0x1040002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _88_in_array_creation_expression1550 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_list_in_array_creation_expression1554 = new BitSet(new ulong[]{0x0UL,0x2000000UL});
		public static readonly BitSet _89_in_array_creation_expression1558 = new BitSet(new ulong[]{0x4000000001E0C012UL,0x5040002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _rank_specifiers_in_array_creation_expression1570 = new BitSet(new ulong[]{0x4000000001E00012UL,0x1040002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _array_initializer_in_array_creation_expression1575 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _arguments_in_array_creation_expression1611 = new BitSet(new ulong[]{0xC000UL,0x5000000UL});
		public static readonly BitSet _invocation_part_in_array_creation_expression1615 = new BitSet(new ulong[]{0xC000UL,0x5000000UL});
		public static readonly BitSet _invocation_part_in_array_creation_expression1627 = new BitSet(new ulong[]{0xC000UL,0x5000000UL});
		public static readonly BitSet _arguments_in_array_creation_expression1633 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _array_initializer_in_array_creation_expression1655 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _rank_specifier_in_array_creation_expression1669 = new BitSet(new ulong[]{0x4000000001E00010UL,0x1040002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _array_initializer_in_array_creation_expression1678 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _62_in_array_initializer1701 = new BitSet(new ulong[]{0xC000000001E13FF0UL,0x20075F8DDC0012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _variable_initializer_list_in_array_initializer1705 = new BitSet(new ulong[]{0x8000000000000000UL,0x8000000UL});
		public static readonly BitSet _91_in_array_initializer1710 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_array_initializer1715 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _variable_initializer_in_variable_initializer_list1725 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_variable_initializer_list1728 = new BitSet(new ulong[]{0x4000000001E13FF0UL,0x20075F85DC0012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _variable_initializer_in_variable_initializer_list1730 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _expression_in_variable_initializer1742 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _array_initializer_in_variable_initializer1746 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _95_in_sizeof_expression1756 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_sizeof_expression1760 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unmanaged_type_in_sizeof_expression1764 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_sizeof_expression1768 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _96_in_checked_expression1778 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_checked_expression1782 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_checked_expression1786 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_checked_expression1790 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _97_in_unchecked_expression1801 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_unchecked_expression1805 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_unchecked_expression1809 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_unchecked_expression1813 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _98_in_default_value_expression1824 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_default_value_expression1828 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_default_value_expression1832 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_default_value_expression1836 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _99_in_anonymous_method_expression1846 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _explicit_anonymous_function_signature_in_anonymous_method_expression1850 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _block_in_anonymous_method_expression1855 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _90_in_explicit_anonymous_function_signature1864 = new BitSet(new ulong[]{0x5E00010UL,0x60040002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _explicit_anonymous_function_parameter_list_in_explicit_anonymous_function_signature1868 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_explicit_anonymous_function_signature1873 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _explicit_anonymous_function_parameter_in_explicit_anonymous_function_parameter_list1883 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_explicit_anonymous_function_parameter_list1888 = new BitSet(new ulong[]{0x1E00010UL,0x60040002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _explicit_anonymous_function_parameter_in_explicit_anonymous_function_parameter_list1892 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _anonymous_function_parameter_modifier_in_explicit_anonymous_function_parameter1905 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_explicit_anonymous_function_parameter1910 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_explicit_anonymous_function_parameter1914 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_anonymous_function_parameter_modifier0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_object_creation_expression1942 = new BitSet(new ulong[]{0x4000000000000000UL,0x4000000UL});
		public static readonly BitSet _90_in_object_creation_expression1951 = new BitSet(new ulong[]{0x5E13FF0UL,0x20075FE4D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _argument_list_in_object_creation_expression1955 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_object_creation_expression1960 = new BitSet(new ulong[]{0x4000000000000002UL,0x4000000UL});
		public static readonly BitSet _object_or_collection_initializer_in_object_creation_expression1964 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _object_or_collection_initializer_in_object_creation_expression1975 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _62_in_object_or_collection_initializer1989 = new BitSet(new ulong[]{0xC000000001E13FF0UL,0x20075F8CD80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _object_initializer_in_object_or_collection_initializer1993 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _collection_initializer_in_object_or_collection_initializer2000 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _element_initializer_list_in_collection_initializer2012 = new BitSet(new ulong[]{0x8000000000000000UL,0x8000000UL});
		public static readonly BitSet _91_in_collection_initializer2016 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_collection_initializer2021 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _element_initializer_in_element_initializer_list2032 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_element_initializer_list2036 = new BitSet(new ulong[]{0xC000000001E13FF0UL,0x20075F8CD80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _element_initializer_in_element_initializer_list2038 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _non_assignment_expression_in_element_initializer2051 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _62_in_element_initializer2057 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_list_in_element_initializer2061 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_element_initializer2065 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_initializer_list_in_object_initializer2082 = new BitSet(new ulong[]{0x8000000000000000UL,0x8000000UL});
		public static readonly BitSet _91_in_object_initializer2087 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_object_initializer2092 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_initializer_in_member_initializer_list2103 = new BitSet(new ulong[]{0x0UL,0x8000000UL});
		public static readonly BitSet _91_in_member_initializer_list2107 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _member_initializer_in_member_initializer_list2109 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_member_initializer2121 = new BitSet(new ulong[]{0x0UL,0x4UL});
		public static readonly BitSet _66_in_member_initializer2125 = new BitSet(new ulong[]{0x4000000001E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _initializer_value_in_member_initializer2129 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_initializer_value2140 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _object_or_collection_initializer_in_initializer_value2146 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _100_in_typeof_expression2160 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_typeof_expression2164 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unbound_type_name_in_typeof_expression2175 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _type_in_typeof_expression2186 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _82_in_typeof_expression2198 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_typeof_expression2203 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _unbound_type_name_start_in_unbound_type_name2220 = new BitSet(new ulong[]{0x4000UL,0x2000000000UL});
		public static readonly BitSet _generic_dimension_specifier_in_unbound_type_name2239 = new BitSet(new ulong[]{0x4000UL,0x2000000000UL});
		public static readonly BitSet _unbound_type_name_part_in_unbound_type_name2243 = new BitSet(new ulong[]{0x4000UL,0x2000000000UL});
		public static readonly BitSet _unbound_type_name_part_in_unbound_type_name2250 = new BitSet(new ulong[]{0x4000UL,0x2000000000UL});
		public static readonly BitSet _generic_dimension_specifier_in_unbound_type_name2260 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_unbound_type_name_start2272 = new BitSet(new ulong[]{0x2UL,0x200000UL});
		public static readonly BitSet _85_in_unbound_type_name_start2275 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_unbound_type_name_start2277 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _DOT_in_unbound_type_name_part2288 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_unbound_type_name_part2292 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _101_in_generic_dimension_specifier2302 = new BitSet(new ulong[]{0x20000UL,0x8000000UL});
		public static readonly BitSet _commas_in_generic_dimension_specifier2306 = new BitSet(new ulong[]{0x20000UL});
		public static readonly BitSet _GT_in_generic_dimension_specifier2311 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _91_in_commas2322 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _namespace_or_type_name_in_type_name2340 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_or_generic_in_namespace_or_type_name2351 = new BitSet(new ulong[]{0x4002UL,0x200000UL});
		public static readonly BitSet _85_in_namespace_or_type_name2356 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _type_or_generic_in_namespace_or_type_name2358 = new BitSet(new ulong[]{0x4002UL});
		public static readonly BitSet _DOT_in_namespace_or_type_name2363 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _type_or_generic_in_namespace_or_type_name2367 = new BitSet(new ulong[]{0x4002UL});
		public static readonly BitSet _identifier_in_type_or_generic2389 = new BitSet(new ulong[]{0x0UL,0x2000000000UL});
		public static readonly BitSet _generic_argument_list_in_type_or_generic2393 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_type_or_generic2398 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _qid_start_in_qid2411 = new BitSet(new ulong[]{0xC002UL});
		public static readonly BitSet _qid_part_in_qid2415 = new BitSet(new ulong[]{0xC002UL});
		public static readonly BitSet _predefined_type_in_qid_start2427 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_qid_start2442 = new BitSet(new ulong[]{0x0UL,0x2000000000UL});
		public static readonly BitSet _generic_argument_list_in_qid_start2446 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_qid_start2453 = new BitSet(new ulong[]{0x2UL,0x200000UL});
		public static readonly BitSet _85_in_qid_start2458 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_qid_start2462 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _literal_in_qid_start2469 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _access_identifier_in_qid_part2485 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _101_in_generic_argument_list2497 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_arguments_in_generic_argument_list2501 = new BitSet(new ulong[]{0x20000UL});
		public static readonly BitSet _GT_in_generic_argument_list2505 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_type_arguments2516 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_type_arguments2519 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_type_arguments2521 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _predefined_type_in_type2552 = new BitSet(new ulong[]{0x0UL,0x1000000UL});
		public static readonly BitSet _type_name_in_type2556 = new BitSet(new ulong[]{0x0UL,0x1000000UL});
		public static readonly BitSet _rank_specifiers_in_type2561 = new BitSet(new ulong[]{0x2UL,0x4000000000UL});
		public static readonly BitSet _102_in_type2565 = new BitSet(new ulong[]{0x2UL,0x4000000000UL});
		public static readonly BitSet _predefined_type_in_type2594 = new BitSet(new ulong[]{0x0UL,0xC000000000UL});
		public static readonly BitSet _type_name_in_type2598 = new BitSet(new ulong[]{0x0UL,0xC000000000UL});
		public static readonly BitSet _102_in_type2604 = new BitSet(new ulong[]{0x2UL,0x4000000000UL});
		public static readonly BitSet _103_in_type2609 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _predefined_type_in_type2616 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_name_in_type2620 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _82_in_type2626 = new BitSet(new ulong[]{0x0UL,0x4000000000UL});
		public static readonly BitSet _102_in_type2628 = new BitSet(new ulong[]{0x2UL,0x4000000000UL});
		public static readonly BitSet _predefined_type_in_non_nullable_type2641 = new BitSet(new ulong[]{0x2UL,0x4001000000UL});
		public static readonly BitSet _type_name_in_non_nullable_type2645 = new BitSet(new ulong[]{0x2UL,0x4001000000UL});
		public static readonly BitSet _rank_specifiers_in_non_nullable_type2654 = new BitSet(new ulong[]{0x2UL,0x4000000000UL});
		public static readonly BitSet _102_in_non_nullable_type2658 = new BitSet(new ulong[]{0x2UL,0x4000000000UL});
		public static readonly BitSet _102_in_non_nullable_type2667 = new BitSet(new ulong[]{0x2UL,0x4000000000UL});
		public static readonly BitSet _82_in_non_nullable_type2679 = new BitSet(new ulong[]{0x0UL,0x4000000000UL});
		public static readonly BitSet _102_in_non_nullable_type2683 = new BitSet(new ulong[]{0x2UL,0x4000000000UL});
		public static readonly BitSet _type_in_non_array_type2696 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_array_type2705 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_unmanaged_type2714 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_class_type2723 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_pointer_type2732 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _SEMI_in_block2746 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _62_in_block2751 = new BitSet(new ulong[]{0xC000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _statement_list_in_block2755 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_block2760 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _statement_in_statement_list2769 = new BitSet(new ulong[]{0x4000000003F53FF2UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _assignment_in_expression2796 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _non_assignment_expression_in_expression2802 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_expression_list2813 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_expression_list2817 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_expression_list2821 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _unary_expression_in_assignment2833 = new BitSet(new ulong[]{0x20000UL,0xFF80000000004UL});
		public static readonly BitSet _assignment_operator_in_assignment2837 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_assignment2841 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _cast_expression_in_unary_expression2860 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _primary_or_array_creation_expression_in_unary_expression2865 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _104_in_unary_expression2870 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unary_expression_in_unary_expression2874 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _MINUS_in_unary_expression2880 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unary_expression_in_unary_expression2884 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _105_in_unary_expression2890 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unary_expression_in_unary_expression2894 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _106_in_unary_expression2900 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unary_expression_in_unary_expression2904 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _pre_increment_expression_in_unary_expression2910 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _pre_decrement_expression_in_unary_expression2916 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _pointer_indirection_expression_in_unary_expression2922 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _addressof_expression_in_unary_expression2927 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _90_in_cast_expression2939 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_cast_expression2943 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_cast_expression2947 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unary_expression_in_cast_expression2951 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _66_in_assignment_operator2961 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _107_in_assignment_operator2965 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _108_in_assignment_operator2969 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _109_in_assignment_operator2973 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _110_in_assignment_operator2977 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _111_in_assignment_operator2981 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _112_in_assignment_operator2985 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _113_in_assignment_operator2989 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _114_in_assignment_operator2993 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _115_in_assignment_operator2997 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _GT_in_assignment_operator3001 = new BitSet(new ulong[]{0x0UL,0x10000000000000UL});
		public static readonly BitSet _116_in_assignment_operator3003 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _86_in_pre_increment_expression3014 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unary_expression_in_pre_increment_expression3018 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _87_in_pre_decrement_expression3029 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unary_expression_in_pre_decrement_expression3033 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _102_in_pointer_indirection_expression3043 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unary_expression_in_pointer_indirection_expression3047 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _117_in_addressof_expression3057 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unary_expression_in_addressof_expression3061 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _lambda_expression_in_non_assignment_expression3084 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _query_expression_in_non_assignment_expression3095 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _conditional_expression_in_non_assignment_expression3101 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _unary_expression_in_multiplicative_expression3117 = new BitSet(new ulong[]{0x2UL,0xC0004000000000UL});
		public static readonly BitSet _set_in_multiplicative_expression3122 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unary_expression_in_multiplicative_expression3132 = new BitSet(new ulong[]{0x2UL,0xC0004000000000UL});
		public static readonly BitSet _multiplicative_expression_in_additive_expression3144 = new BitSet(new ulong[]{0x10002UL,0x10000000000UL});
		public static readonly BitSet _set_in_additive_expression3147 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _multiplicative_expression_in_additive_expression3155 = new BitSet(new ulong[]{0x10002UL,0x10000000000UL});
		public static readonly BitSet _additive_expression_in_shift_expression3168 = new BitSet(new ulong[]{0x20002UL,0x100000000000000UL});
		public static readonly BitSet _120_in_shift_expression3172 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _GT_in_shift_expression3174 = new BitSet(new ulong[]{0x20000UL});
		public static readonly BitSet _GT_in_shift_expression3176 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _additive_expression_in_shift_expression3179 = new BitSet(new ulong[]{0x20002UL,0x100000000000000UL});
		public static readonly BitSet _shift_expression_in_relational_expression3191 = new BitSet(new ulong[]{0x20002UL,0xE10002000000000UL});
		public static readonly BitSet _set_in_relational_expression3198 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _shift_expression_in_relational_expression3208 = new BitSet(new ulong[]{0x20002UL,0xE10002000000000UL});
		public static readonly BitSet _set_in_relational_expression3217 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _non_nullable_type_in_relational_expression3225 = new BitSet(new ulong[]{0x20002UL,0xE10002000000000UL});
		public static readonly BitSet _relational_expression_in_equality_expression3241 = new BitSet(new ulong[]{0x2UL,0x3000000000000000UL});
		public static readonly BitSet _set_in_equality_expression3248 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _relational_expression_in_equality_expression3256 = new BitSet(new ulong[]{0x2UL,0x3000000000000000UL});
		public static readonly BitSet _equality_expression_in_and_expression3268 = new BitSet(new ulong[]{0x2UL,0x20000000000000UL});
		public static readonly BitSet _117_in_and_expression3271 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _equality_expression_in_and_expression3275 = new BitSet(new ulong[]{0x2UL,0x20000000000000UL});
		public static readonly BitSet _and_expression_in_exclusive_or_expression3287 = new BitSet(new ulong[]{0x2UL,0x4000000000000000UL});
		public static readonly BitSet _126_in_exclusive_or_expression3290 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _and_expression_in_exclusive_or_expression3294 = new BitSet(new ulong[]{0x2UL,0x4000000000000000UL});
		public static readonly BitSet _exclusive_or_expression_in_inclusive_or_expression3306 = new BitSet(new ulong[]{0x2UL,0x8000000000000000UL});
		public static readonly BitSet _127_in_inclusive_or_expression3311 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _exclusive_or_expression_in_inclusive_or_expression3315 = new BitSet(new ulong[]{0x2UL,0x8000000000000000UL});
		public static readonly BitSet _inclusive_or_expression_in_conditional_and_expression3327 = new BitSet(new ulong[]{0x2UL,0x0UL,0x1UL});
		public static readonly BitSet _128_in_conditional_and_expression3332 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _inclusive_or_expression_in_conditional_and_expression3336 = new BitSet(new ulong[]{0x2UL,0x0UL,0x1UL});
		public static readonly BitSet _conditional_and_expression_in_conditional_or_expression3348 = new BitSet(new ulong[]{0x2UL,0x0UL,0x2UL});
		public static readonly BitSet _129_in_conditional_or_expression3352 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _conditional_and_expression_in_conditional_or_expression3356 = new BitSet(new ulong[]{0x2UL,0x0UL,0x2UL});
		public static readonly BitSet _conditional_or_expression_in_null_coalescing_expression3369 = new BitSet(new ulong[]{0x2UL,0x0UL,0x4UL});
		public static readonly BitSet _130_in_null_coalescing_expression3374 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _conditional_or_expression_in_null_coalescing_expression3378 = new BitSet(new ulong[]{0x2UL,0x0UL,0x4UL});
		public static readonly BitSet _null_coalescing_expression_in_conditional_expression3390 = new BitSet(new ulong[]{0x2UL,0x8000000000UL});
		public static readonly BitSet _103_in_conditional_expression3395 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_conditional_expression3399 = new BitSet(new ulong[]{0x0UL,0x10000000UL});
		public static readonly BitSet _92_in_conditional_expression3403 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_conditional_expression3407 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _anonymous_function_signature_in_lambda_expression3429 = new BitSet(new ulong[]{0x0UL,0x0UL,0x8UL});
		public static readonly BitSet _131_in_lambda_expression3433 = new BitSet(new ulong[]{0x4000000003E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _anonymous_function_body_in_lambda_expression3437 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _90_in_anonymous_function_signature3446 = new BitSet(new ulong[]{0x5E00010UL,0x64040002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _explicit_anonymous_function_parameter_list_in_anonymous_function_signature3449 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _implicit_anonymous_function_parameter_list_in_anonymous_function_signature3455 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_anonymous_function_signature3459 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _implicit_anonymous_function_parameter_list_in_anonymous_function_signature3464 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _implicit_anonymous_function_parameter_in_implicit_anonymous_function_parameter_list3475 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_implicit_anonymous_function_parameter_list3480 = new BitSet(new ulong[]{0x1E00010UL,0x4000002UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _implicit_anonymous_function_parameter_in_implicit_anonymous_function_parameter_list3484 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _identifier_in_implicit_anonymous_function_parameter3496 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_anonymous_function_body3505 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _block_in_anonymous_function_body3510 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _from_clause_in_query_expression3524 = new BitSet(new ulong[]{0x0UL,0x0UL,0x2CCA0UL});
		public static readonly BitSet _query_body_in_query_expression3528 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _query_body_clauses_in_query_body3540 = new BitSet(new ulong[]{0x0UL,0x0UL,0x2CCA0UL});
		public static readonly BitSet _select_or_group_clause_in_query_body3545 = new BitSet(new ulong[]{0x2UL,0x0UL,0x10UL});
		public static readonly BitSet _query_continuation_in_query_body3556 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _132_in_query_continuation3568 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_query_continuation3572 = new BitSet(new ulong[]{0x0UL,0x0UL,0x2CCA0UL});
		public static readonly BitSet _query_body_in_query_continuation3576 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _query_body_clause_in_query_body_clauses3585 = new BitSet(new ulong[]{0x2UL,0x0UL,0x20CA0UL});
		public static readonly BitSet _from_clause_in_query_body_clause3596 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _let_clause_in_query_body_clause3601 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _where_clause_in_query_body_clause3606 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _join_clause_in_query_body_clause3611 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _orderby_clause_in_query_body_clause3616 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _133_in_from_clause3625 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_from_clause3629 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_from_clause3634 = new BitSet(new ulong[]{0x0UL,0x0UL,0x40UL});
		public static readonly BitSet _134_in_from_clause3638 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_from_clause3642 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _135_in_join_clause3652 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_join_clause3656 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_join_clause3661 = new BitSet(new ulong[]{0x0UL,0x0UL,0x40UL});
		public static readonly BitSet _134_in_join_clause3665 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_join_clause3669 = new BitSet(new ulong[]{0x0UL,0x0UL,0x100UL});
		public static readonly BitSet _136_in_join_clause3673 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_join_clause3677 = new BitSet(new ulong[]{0x0UL,0x0UL,0x200UL});
		public static readonly BitSet _137_in_join_clause3681 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_join_clause3685 = new BitSet(new ulong[]{0x2UL,0x0UL,0x10UL});
		public static readonly BitSet _132_in_join_clause3688 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_join_clause3690 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _138_in_let_clause3702 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_let_clause3706 = new BitSet(new ulong[]{0x0UL,0x4UL});
		public static readonly BitSet _66_in_let_clause3710 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_let_clause3714 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _139_in_orderby_clause3723 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _ordering_list_in_orderby_clause3727 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _ordering_in_ordering_list3737 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_ordering_list3742 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _ordering_in_ordering_list3746 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _expression_in_ordering3758 = new BitSet(new ulong[]{0x0UL,0x0UL,0x3000UL});
		public static readonly BitSet _ordering_direction_in_ordering3763 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_ordering_direction0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _select_clause_in_select_or_group_clause3789 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _group_clause_in_select_or_group_clause3794 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _142_in_select_clause3804 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_select_clause3808 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _143_in_group_clause3818 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_group_clause3822 = new BitSet(new ulong[]{0x0UL,0x0UL,0x10000UL});
		public static readonly BitSet _144_in_group_clause3826 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_group_clause3830 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _145_in_where_clause3840 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _boolean_expression_in_where_clause3844 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_boolean_expression3854 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _global_attribute_in_global_attributes3868 = new BitSet(new ulong[]{0x2UL,0x1000000UL});
		public static readonly BitSet _88_in_global_attribute3880 = new BitSet(new ulong[]{0x0UL,0x0UL,0xC0000UL});
		public static readonly BitSet _global_attribute_target_specifier_in_global_attribute3884 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _attribute_list_in_global_attribute3888 = new BitSet(new ulong[]{0x0UL,0xA000000UL});
		public static readonly BitSet _91_in_global_attribute3892 = new BitSet(new ulong[]{0x0UL,0x2000000UL});
		public static readonly BitSet _89_in_global_attribute3897 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _global_attribute_target_in_global_attribute_target_specifier3908 = new BitSet(new ulong[]{0x0UL,0x10000000UL});
		public static readonly BitSet _92_in_global_attribute_target_specifier3912 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_global_attribute_target0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _attribute_sections_in_attributes3938 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _attribute_section_in_attribute_sections3949 = new BitSet(new ulong[]{0x2UL,0x1000000UL});
		public static readonly BitSet _88_in_attribute_section3961 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x605FFF7FFFFB0UL,0x7F8UL});
		public static readonly BitSet _attribute_target_specifier_in_attribute_section3965 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _attribute_list_in_attribute_section3970 = new BitSet(new ulong[]{0x0UL,0xA000000UL});
		public static readonly BitSet _91_in_attribute_section3974 = new BitSet(new ulong[]{0x0UL,0x2000000UL});
		public static readonly BitSet _89_in_attribute_section3979 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _attribute_target_in_attribute_target_specifier3990 = new BitSet(new ulong[]{0x0UL,0x10000000UL});
		public static readonly BitSet _92_in_attribute_target_specifier3994 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_attribute_target0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _attribute_in_attribute_list4040 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_attribute_list4043 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _attribute_in_attribute_list4045 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _type_name_in_attribute4059 = new BitSet(new ulong[]{0x2UL,0x4000000UL});
		public static readonly BitSet _attribute_arguments_in_attribute4063 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _90_in_attribute_arguments4076 = new BitSet(new ulong[]{0x5E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _RPAREN_in_attribute_arguments4081 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _positional_argument_in_attribute_arguments4101 = new BitSet(new ulong[]{0x5E00010UL,0x8000002UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _named_argument_in_attribute_arguments4120 = new BitSet(new ulong[]{0x5E00010UL,0x8000002UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _91_in_attribute_arguments4136 = new BitSet(new ulong[]{0x5E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _positional_argument_in_attribute_arguments4138 = new BitSet(new ulong[]{0x5E00010UL,0x8000002UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _RPAREN_in_attribute_arguments4149 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _positional_argument_in_positional_argument_list4165 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_positional_argument_list4168 = new BitSet(new ulong[]{0x5E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _positional_argument_in_positional_argument_list4170 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _attribute_argument_expression_in_positional_argument4183 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _named_argument_in_named_argument_list4194 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_named_argument_list4197 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _named_argument_in_named_argument_list4199 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _identifier_in_named_argument4212 = new BitSet(new ulong[]{0x0UL,0x4UL});
		public static readonly BitSet _66_in_named_argument4216 = new BitSet(new ulong[]{0x5E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _attribute_argument_expression_in_named_argument4220 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_attribute_argument_expression4231 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _155_in_class_declaration4246 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _type_or_generic_in_class_declaration4249 = new BitSet(new ulong[]{0x4000000000000000UL,0x10000000UL,0x20000UL});
		public static readonly BitSet _class_base_in_class_declaration4253 = new BitSet(new ulong[]{0x4000000000000000UL,0x10000000UL,0x20000UL});
		public static readonly BitSet _type_parameter_constraints_clauses_in_class_declaration4258 = new BitSet(new ulong[]{0x4000000000000000UL,0x10000000UL,0x20000UL});
		public static readonly BitSet _class_body_in_class_declaration4263 = new BitSet(new ulong[]{0x2000002UL});
		public static readonly BitSet _SEMI_in_class_declaration4267 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _92_in_class_base4282 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _interface_type_list_in_class_base4286 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_interface_type_list4298 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_interface_type_list4301 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_interface_type_list4305 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _62_in_class_body4318 = new BitSet(new ulong[]{0xA000000001E80010UL,0x4080107FFFBUL,0x6D7FFFDFFFFB0UL,0x7F8UL});
		public static readonly BitSet _class_member_declarations_in_class_body4322 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_class_body4327 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _class_member_declaration_in_class_member_declarations4337 = new BitSet(new ulong[]{0x2000000001E80012UL,0x4080107FFFBUL,0x6D7FFFDFFFFB0UL,0x7F8UL});
		public static readonly BitSet _81_in_constant_declaration4350 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_constant_declaration4354 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _constant_declarators_in_constant_declaration4358 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_constant_declaration4362 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _constant_declarator_in_constant_declarators4372 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_constant_declarators4375 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _constant_declarator_in_constant_declarators4377 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _identifier_in_constant_declarator4389 = new BitSet(new ulong[]{0x2UL,0x4UL});
		public static readonly BitSet _66_in_constant_declarator4394 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _constant_expression_in_constant_declarator4398 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_constant_expression4410 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _variable_declarators_in_field_declaration4421 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_field_declaration4425 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _variable_declarator_in_variable_declarators4435 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_variable_declarators4438 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _variable_declarator_in_variable_declarators4442 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _type_name_in_variable_declarator4454 = new BitSet(new ulong[]{0x2UL,0x4UL});
		public static readonly BitSet _66_in_variable_declarator4457 = new BitSet(new ulong[]{0x4000000001E13FF0UL,0x20075F85DC0012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _variable_initializer_in_variable_declarator4461 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _method_header_in_method_declaration4477 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _method_body_in_method_declaration4481 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_name_in_method_header4491 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_method_header4494 = new BitSet(new ulong[]{0x5E00010UL,0x610C0002UL,0x60DFFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _formal_parameter_list_in_method_header4498 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_method_header4503 = new BitSet(new ulong[]{0x2UL,0x0UL,0x20000UL});
		public static readonly BitSet _type_parameter_constraints_clauses_in_method_header4507 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _block_in_method_body4518 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _qid_in_member_name4528 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_name_in_property_declaration4542 = new BitSet(new ulong[]{0x4000000000000000UL});
		public static readonly BitSet _62_in_property_declaration4546 = new BitSet(new ulong[]{0x0UL,0x10001E0UL,0x30000000UL});
		public static readonly BitSet _accessor_declarations_in_property_declaration4550 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_property_declaration4554 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _attributes_in_accessor_declarations4564 = new BitSet(new ulong[]{0x0UL,0x10001E0UL,0x30000000UL});
		public static readonly BitSet _get_accessor_declaration_in_accessor_declarations4570 = new BitSet(new ulong[]{0x2UL,0x10001E0UL,0x30000000UL});
		public static readonly BitSet _attributes_in_accessor_declarations4574 = new BitSet(new ulong[]{0x2UL,0x10001E0UL,0x30000000UL});
		public static readonly BitSet _set_accessor_declaration_in_accessor_declarations4579 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_accessor_declaration_in_accessor_declarations4586 = new BitSet(new ulong[]{0x2UL,0x10001E0UL,0x10000000UL});
		public static readonly BitSet _attributes_in_accessor_declarations4590 = new BitSet(new ulong[]{0x2UL,0x1E0UL,0x10000000UL});
		public static readonly BitSet _get_accessor_declaration_in_accessor_declarations4595 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _accessor_modifier_in_get_accessor_declaration4607 = new BitSet(new ulong[]{0x0UL,0x0UL,0x10000000UL});
		public static readonly BitSet _156_in_get_accessor_declaration4612 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _accessor_body_in_get_accessor_declaration4616 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _accessor_modifier_in_set_accessor_declaration4626 = new BitSet(new ulong[]{0x0UL,0x0UL,0x20000000UL});
		public static readonly BitSet _157_in_set_accessor_declaration4631 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _accessor_body_in_set_accessor_declaration4635 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_accessor_modifier0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _block_in_accessor_body4667 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _149_in_event_declaration4679 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_event_declaration4683 = new BitSet(new ulong[]{0x1E03FF0UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _member_name_in_event_declaration4698 = new BitSet(new ulong[]{0x4000000000000000UL});
		public static readonly BitSet _62_in_event_declaration4702 = new BitSet(new ulong[]{0x0UL,0x1000000UL,0xC0000000UL});
		public static readonly BitSet _event_accessor_declarations_in_event_declaration4706 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_event_declaration4710 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _variable_declarators_in_event_declaration4716 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_event_declaration4720 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _modifier_in_event_modifiers4734 = new BitSet(new ulong[]{0x2UL,0x1FFF1UL});
		public static readonly BitSet _attributes_in_event_accessor_declarations4745 = new BitSet(new ulong[]{0x0UL,0x1000000UL,0xC0000000UL});
		public static readonly BitSet _add_accessor_declaration_in_event_accessor_declarations4752 = new BitSet(new ulong[]{0x0UL,0x1000000UL,0xC0000000UL});
		public static readonly BitSet _attributes_in_event_accessor_declarations4756 = new BitSet(new ulong[]{0x0UL,0x1000000UL,0xC0000000UL});
		public static readonly BitSet _remove_accessor_declaration_in_event_accessor_declarations4761 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _remove_accessor_declaration_in_event_accessor_declarations4782 = new BitSet(new ulong[]{0x0UL,0x1000000UL,0x40000000UL});
		public static readonly BitSet _attributes_in_event_accessor_declarations4786 = new BitSet(new ulong[]{0x0UL,0x0UL,0x40000000UL});
		public static readonly BitSet _add_accessor_declaration_in_event_accessor_declarations4791 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _158_in_add_accessor_declaration4803 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _block_in_add_accessor_declaration4807 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _159_in_remove_accessor_declaration4817 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _block_in_remove_accessor_declaration4821 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _ENUM_in_enum_declaration4835 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_enum_declaration4839 = new BitSet(new ulong[]{0x4000000000000000UL,0x10000000UL});
		public static readonly BitSet _enum_base_in_enum_declaration4843 = new BitSet(new ulong[]{0x4000000000000000UL,0x10000000UL});
		public static readonly BitSet _enum_body_in_enum_declaration4848 = new BitSet(new ulong[]{0x2000002UL});
		public static readonly BitSet _SEMI_in_enum_declaration4852 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _92_in_enum_base4863 = new BitSet(new ulong[]{0x0UL,0x0UL,0x1FF00000000UL});
		public static readonly BitSet _integral_type_in_enum_base4867 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _62_in_enum_body4877 = new BitSet(new ulong[]{0x8000000001E00010UL,0x1000002UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _enum_member_declarations_in_enum_body4880 = new BitSet(new ulong[]{0x8000000000000000UL,0x8000000UL});
		public static readonly BitSet _91_in_enum_body4882 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_enum_body4889 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _enum_member_declaration_in_enum_member_declarations4899 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_enum_member_declarations4902 = new BitSet(new ulong[]{0x1E00010UL,0x1000002UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _enum_member_declaration_in_enum_member_declarations4904 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _attributes_in_enum_member_declaration4916 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_enum_member_declaration4921 = new BitSet(new ulong[]{0x2UL,0x4UL});
		public static readonly BitSet _66_in_enum_member_declaration4926 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_enum_member_declaration4930 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_integral_type0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _99_in_delegate_declaration4991 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _return_type_in_delegate_declaration4995 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_delegate_declaration4999 = new BitSet(new ulong[]{0x0UL,0x2004000000UL});
		public static readonly BitSet _variant_generic_parameter_list_in_delegate_declaration5002 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_delegate_declaration5010 = new BitSet(new ulong[]{0x5E00010UL,0x610C0002UL,0x60DFFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _formal_parameter_list_in_delegate_declaration5014 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_delegate_declaration5019 = new BitSet(new ulong[]{0x2000000UL,0x0UL,0x20000UL});
		public static readonly BitSet _type_parameter_constraints_clauses_in_delegate_declaration5023 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_delegate_declaration5028 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _modifier_in_delegate_modifiers5038 = new BitSet(new ulong[]{0x2UL,0x1FFF1UL});
		public static readonly BitSet _101_in_variant_generic_parameter_list5050 = new BitSet(new ulong[]{0x1E00010UL,0x21000002UL,0x60400F5DFFFF0UL,0x408UL});
		public static readonly BitSet _variant_type_parameters_in_variant_generic_parameter_list5054 = new BitSet(new ulong[]{0x20000UL});
		public static readonly BitSet _GT_in_variant_generic_parameter_list5058 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _variant_type_variable_name_in_variant_type_parameters5068 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_variant_type_parameters5071 = new BitSet(new ulong[]{0x1E00010UL,0x21000002UL,0x60400F5DFFFF0UL,0x408UL});
		public static readonly BitSet _variant_type_variable_name_in_variant_type_parameters5073 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _attributes_in_variant_type_variable_name5085 = new BitSet(new ulong[]{0x1E00010UL,0x21000002UL,0x60400F5DFFFF0UL,0x408UL});
		public static readonly BitSet _variance_annotation_in_variant_type_variable_name5090 = new BitSet(new ulong[]{0x1E00010UL,0x21000002UL,0x60400F5DFFFF0UL,0x408UL});
		public static readonly BitSet _type_variable_name_in_variant_type_variable_name5095 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_variance_annotation0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_parameter_constraints_clause_in_type_parameter_constraints_clauses5120 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_type_parameter_constraints_clauses5125 = new BitSet(new ulong[]{0x0UL,0x0UL,0x20000UL});
		public static readonly BitSet _type_parameter_constraints_clause_in_type_parameter_constraints_clauses5129 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _145_in_type_parameter_constraints_clause5141 = new BitSet(new ulong[]{0x1E00010UL,0x21000002UL,0x60400F5DFFFF0UL,0x408UL});
		public static readonly BitSet _type_variable_name_in_type_parameter_constraints_clause5145 = new BitSet(new ulong[]{0x0UL,0x10000000UL});
		public static readonly BitSet _92_in_type_parameter_constraints_clause5149 = new BitSet(new ulong[]{0x1E00010UL,0x12UL,0x607FFFDDFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_parameter_constraint_list_in_type_parameter_constraints_clause5153 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_type_parameter_constraint_list5218 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_type_parameter_constraint_list5229 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _secondary_constraint_list_in_type_parameter_constraint_list5233 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_type_parameter_constraint_list5240 = new BitSet(new ulong[]{0x1E00010UL,0x12UL,0x607FFFDDFFFB0UL,0x7F8UL});
		public static readonly BitSet _constructor_constraint_in_type_parameter_constraint_list5244 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _secondary_constraint_list_in_type_parameter_constraint_list5251 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_type_parameter_constraint_list5256 = new BitSet(new ulong[]{0x1E00010UL,0x12UL,0x607FFFDDFFFB0UL,0x7F8UL});
		public static readonly BitSet _constructor_constraint_in_type_parameter_constraint_list5260 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _constructor_constraint_in_type_parameter_constraint_list5267 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _secondary_constraint_in_secondary_constraint_list5281 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_secondary_constraint_list5284 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _secondary_constraint_in_secondary_constraint_list5286 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _type_name_in_secondary_constraint5298 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_type_variable_name5310 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _68_in_constructor_constraint5320 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_constructor_constraint5324 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_constructor_constraint5328 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_return_type5338 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _82_in_return_type5344 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _formal_parameter_in_formal_parameter_list5353 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_formal_parameter_list5356 = new BitSet(new ulong[]{0x1E00010UL,0x610C0002UL,0x60DFFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _formal_parameter_in_formal_parameter_list5358 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _attributes_in_formal_parameter5370 = new BitSet(new ulong[]{0x1E00010UL,0x610C0002UL,0x60DFFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _fixed_parameter_in_formal_parameter5376 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _parameter_array_in_formal_parameter5380 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _170_in_formal_parameter5387 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _fixed_parameter_in_fixed_parameters5397 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_fixed_parameters5402 = new BitSet(new ulong[]{0x1E00010UL,0x600C0002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _fixed_parameter_in_fixed_parameters5406 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _parameter_modifier_in_fixed_parameter5419 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_fixed_parameter5424 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_fixed_parameter5428 = new BitSet(new ulong[]{0x2UL,0x4UL});
		public static readonly BitSet _default_argument_in_fixed_parameter5432 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _66_in_default_argument5444 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_default_argument5446 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_parameter_modifier0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _171_in_parameter_array5473 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_parameter_array5477 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_parameter_array5481 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _172_in_interface_declaration5493 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_interface_declaration5497 = new BitSet(new ulong[]{0x4000000000000000UL,0x2010000000UL,0x20000UL});
		public static readonly BitSet _variant_generic_parameter_list_in_interface_declaration5501 = new BitSet(new ulong[]{0x4000000000000000UL,0x2010000000UL,0x20000UL});
		public static readonly BitSet _interface_base_in_interface_declaration5510 = new BitSet(new ulong[]{0x4000000000000000UL,0x2010000000UL,0x20000UL});
		public static readonly BitSet _type_parameter_constraints_clauses_in_interface_declaration5515 = new BitSet(new ulong[]{0x4000000000000000UL,0x2010000000UL,0x20000UL});
		public static readonly BitSet _interface_body_in_interface_declaration5520 = new BitSet(new ulong[]{0x2000002UL});
		public static readonly BitSet _SEMI_in_interface_declaration5524 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _modifier_in_interface_modifiers5536 = new BitSet(new ulong[]{0x2UL,0x1FFF1UL});
		public static readonly BitSet _92_in_interface_base5551 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _interface_type_list_in_interface_base5553 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _62_in_interface_body5563 = new BitSet(new ulong[]{0x8000000001E00010UL,0x105FFF3UL,0x605FFF5FFFFB0UL,0x7F8UL});
		public static readonly BitSet _interface_member_declarations_in_interface_body5567 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_interface_body5572 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _interface_member_declaration_in_interface_member_declarations5582 = new BitSet(new ulong[]{0x1E00012UL,0x105FFF3UL,0x605FFF5FFFFB0UL,0x7F8UL});
		public static readonly BitSet _attributes_in_interface_member_declaration5593 = new BitSet(new ulong[]{0x1E00010UL,0x5FFF3UL,0x605FFF5FFFFB0UL,0x7F8UL});
		public static readonly BitSet _modifiers_in_interface_member_declaration5599 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5FFFFB0UL,0x7F8UL});
		public static readonly BitSet _82_in_interface_member_declaration5605 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _interface_method_declaration_in_interface_member_declaration5609 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _interface_event_declaration_in_interface_member_declaration5615 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_interface_member_declaration5621 = new BitSet(new ulong[]{0x1E00010UL,0x80002UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _interface_method_declaration_in_interface_member_declaration5637 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _interface_property_declaration_in_interface_member_declaration5662 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _interface_indexer_declaration_in_interface_member_declaration5672 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_interface_property_declaration5691 = new BitSet(new ulong[]{0x4000000000000000UL});
		public static readonly BitSet _62_in_interface_property_declaration5695 = new BitSet(new ulong[]{0x0UL,0x1000000UL,0x30000000UL});
		public static readonly BitSet _interface_accessor_declarations_in_interface_property_declaration5699 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_interface_property_declaration5703 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_interface_method_declaration5713 = new BitSet(new ulong[]{0x0UL,0x2004000000UL});
		public static readonly BitSet _generic_argument_list_in_interface_method_declaration5717 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_interface_method_declaration5725 = new BitSet(new ulong[]{0x5E00010UL,0x610C0002UL,0x60DFFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _formal_parameter_list_in_interface_method_declaration5729 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_interface_method_declaration5734 = new BitSet(new ulong[]{0x2000000UL,0x0UL,0x20000UL});
		public static readonly BitSet _type_parameter_constraints_clauses_in_interface_method_declaration5738 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_interface_method_declaration5743 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _149_in_interface_event_declaration5756 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_interface_event_declaration5760 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_interface_event_declaration5764 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_interface_event_declaration5768 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _83_in_interface_indexer_declaration5782 = new BitSet(new ulong[]{0x0UL,0x1000000UL});
		public static readonly BitSet _88_in_interface_indexer_declaration5786 = new BitSet(new ulong[]{0x1E00010UL,0x610C0002UL,0x60DFFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _formal_parameter_list_in_interface_indexer_declaration5790 = new BitSet(new ulong[]{0x0UL,0x2000000UL});
		public static readonly BitSet _89_in_interface_indexer_declaration5794 = new BitSet(new ulong[]{0x4000000000000000UL});
		public static readonly BitSet _62_in_interface_indexer_declaration5798 = new BitSet(new ulong[]{0x0UL,0x1000000UL,0x30000000UL});
		public static readonly BitSet _interface_accessor_declarations_in_interface_indexer_declaration5802 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_interface_indexer_declaration5806 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _attributes_in_interface_accessor_declarations5816 = new BitSet(new ulong[]{0x0UL,0x1000000UL,0x30000000UL});
		public static readonly BitSet _interface_get_accessor_declaration_in_interface_accessor_declarations5825 = new BitSet(new ulong[]{0x2UL,0x1000000UL,0x30000000UL});
		public static readonly BitSet _attributes_in_interface_accessor_declarations5829 = new BitSet(new ulong[]{0x2UL,0x1000000UL,0x30000000UL});
		public static readonly BitSet _interface_set_accessor_declaration_in_interface_accessor_declarations5834 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _interface_set_accessor_declaration_in_interface_accessor_declarations5841 = new BitSet(new ulong[]{0x2UL,0x1000000UL,0x10000000UL});
		public static readonly BitSet _attributes_in_interface_accessor_declarations5845 = new BitSet(new ulong[]{0x2UL,0x0UL,0x10000000UL});
		public static readonly BitSet _interface_get_accessor_declaration_in_interface_accessor_declarations5850 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _156_in_interface_get_accessor_declaration5862 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_interface_get_accessor_declaration5866 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _157_in_interface_set_accessor_declaration5878 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_interface_set_accessor_declaration5882 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _modifier_in_method_modifiers5894 = new BitSet(new ulong[]{0x2UL,0x1FFF1UL});
		public static readonly BitSet _169_in_struct_declaration5908 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _type_or_generic_in_struct_declaration5912 = new BitSet(new ulong[]{0x4000000000000000UL,0x10000000UL,0x20000UL});
		public static readonly BitSet _struct_interfaces_in_struct_declaration5916 = new BitSet(new ulong[]{0x4000000000000000UL,0x10000000UL,0x20000UL});
		public static readonly BitSet _type_parameter_constraints_clauses_in_struct_declaration5921 = new BitSet(new ulong[]{0x4000000000000000UL,0x10000000UL,0x20000UL});
		public static readonly BitSet _struct_body_in_struct_declaration5926 = new BitSet(new ulong[]{0x2000002UL});
		public static readonly BitSet _SEMI_in_struct_declaration5930 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _struct_modifier_in_struct_modifiers5941 = new BitSet(new ulong[]{0x2UL,0x3F0UL});
		public static readonly BitSet _set_in_struct_modifier0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _92_in_struct_interfaces5982 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _interface_type_list_in_struct_interfaces5986 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _62_in_struct_body5995 = new BitSet(new ulong[]{0xA000000001E80010UL,0x80107FFFBUL,0x6D7FFFDFFFFB0UL,0x7F8UL});
		public static readonly BitSet _struct_member_declarations_in_struct_body5999 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_struct_body6004 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _struct_member_declaration_in_struct_member_declarations6013 = new BitSet(new ulong[]{0x2000000001E80012UL,0x80107FFFBUL,0x6D7FFFDFFFFB0UL,0x7F8UL});
		public static readonly BitSet _attributes_in_struct_member_declaration6024 = new BitSet(new ulong[]{0x2000000001E80010UL,0x80107FFFBUL,0x6D7FFFDFFFFB0UL,0x7F8UL});
		public static readonly BitSet _modifiers_in_struct_member_declaration6031 = new BitSet(new ulong[]{0x2000000001E80010UL,0x80107FFFBUL,0x6D7FFFDFFFFB0UL,0x7F8UL});
		public static readonly BitSet _81_in_struct_member_declaration6037 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_struct_member_declaration6041 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _constant_declarators_in_struct_member_declaration6045 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_struct_member_declaration6049 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _event_declaration_in_struct_member_declaration6054 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _67_in_struct_member_declaration6061 = new BitSet(new ulong[]{0x1E03FF0UL,0x2UL,0x617FFFDDFFFB0UL,0x7F8UL});
		public static readonly BitSet _method_declaration_in_struct_member_declaration6064 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _interface_declaration_in_struct_member_declaration6075 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _class_declaration_in_struct_member_declaration6086 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _struct_declaration_in_struct_member_declaration6097 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _interface_declaration_in_struct_member_declaration6104 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _class_declaration_in_struct_member_declaration6110 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _82_in_struct_member_declaration6117 = new BitSet(new ulong[]{0x1E03FF0UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _method_declaration_in_struct_member_declaration6121 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_struct_member_declaration6126 = new BitSet(new ulong[]{0x1E03FF0UL,0x80002UL,0x625FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _method_declaration_in_struct_member_declaration6140 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _property_declaration_in_struct_member_declaration6159 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_name_in_struct_member_declaration6182 = new BitSet(new ulong[]{0x4000UL});
		public static readonly BitSet _DOT_in_struct_member_declaration6184 = new BitSet(new ulong[]{0x0UL,0x80000UL});
		public static readonly BitSet _indexer_declaration_in_struct_member_declaration6186 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _indexer_declaration_in_struct_member_declaration6195 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _field_declaration_in_struct_member_declaration6208 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _operator_declaration_in_struct_member_declaration6226 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _struct_declaration_in_struct_member_declaration6244 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _enum_declaration_in_struct_member_declaration6250 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _delegate_declaration_in_struct_member_declaration6257 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _conversion_operator_declaration_in_struct_member_declaration6263 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _constructor_declaration_in_struct_member_declaration6268 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _indexer_declarator_in_indexer_declaration6287 = new BitSet(new ulong[]{0x4000000000000000UL});
		public static readonly BitSet _62_in_indexer_declaration6291 = new BitSet(new ulong[]{0x0UL,0x10001E0UL,0x30000000UL});
		public static readonly BitSet _accessor_declarations_in_indexer_declaration6295 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_indexer_declaration6299 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _83_in_indexer_declarator6311 = new BitSet(new ulong[]{0x0UL,0x1000000UL});
		public static readonly BitSet _88_in_indexer_declarator6315 = new BitSet(new ulong[]{0x1E00010UL,0x610C0002UL,0x60DFFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _formal_parameter_list_in_indexer_declarator6319 = new BitSet(new ulong[]{0x0UL,0x2000000UL});
		public static readonly BitSet _89_in_indexer_declarator6323 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _operator_declarator_in_operator_declaration6336 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _operator_body_in_operator_declaration6340 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _173_in_operator_declarator6350 = new BitSet(new ulong[]{0x31800UL,0xF3F0076000C00000UL});
		public static readonly BitSet _set_in_operator_declarator6355 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_operator_declarator6365 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_operator_declarator6369 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_operator_declarator6373 = new BitSet(new ulong[]{0x4000000UL,0x8000000UL});
		public static readonly BitSet _binary_operator_declarator_in_operator_declarator6378 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _unary_operator_declarator_in_operator_declarator6382 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _overloadable_unary_operator_in_operator_declarator6389 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_operator_declarator6393 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_operator_declarator6397 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_operator_declarator6399 = new BitSet(new ulong[]{0x4000000UL,0x8000000UL});
		public static readonly BitSet _unary_operator_declarator_in_operator_declarator6403 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _overloadable_binary_operator_in_operator_declarator6409 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_operator_declarator6413 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_operator_declarator6417 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_operator_declarator6419 = new BitSet(new ulong[]{0x0UL,0x8000000UL});
		public static readonly BitSet _binary_operator_declarator_in_operator_declarator6423 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _RPAREN_in_unary_operator_declarator6437 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_overloadable_unary_operator0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _91_in_binary_operator_declarator6484 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_binary_operator_declarator6488 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_binary_operator_declarator6492 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_binary_operator_declarator6496 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _102_in_overloadable_binary_operator6509 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _118_in_overloadable_binary_operator6513 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _119_in_overloadable_binary_operator6517 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _117_in_overloadable_binary_operator6521 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _127_in_overloadable_binary_operator6525 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _126_in_overloadable_binary_operator6529 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _120_in_overloadable_binary_operator6533 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _GT_in_overloadable_binary_operator6537 = new BitSet(new ulong[]{0x20000UL});
		public static readonly BitSet _GT_in_overloadable_binary_operator6539 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _124_in_overloadable_binary_operator6543 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _125_in_overloadable_binary_operator6547 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _GT_in_overloadable_binary_operator6551 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _101_in_overloadable_binary_operator6555 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _116_in_overloadable_binary_operator6559 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _121_in_overloadable_binary_operator6563 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _conversion_operator_declarator_in_conversion_operator_declaration6575 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _operator_body_in_conversion_operator_declaration6579 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_conversion_operator_declarator6589 = new BitSet(new ulong[]{0x0UL,0x0UL,0x200000000000UL});
		public static readonly BitSet _173_in_conversion_operator_declarator6598 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_conversion_operator_declarator6602 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_conversion_operator_declarator6606 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_conversion_operator_declarator6610 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_conversion_operator_declarator6614 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_conversion_operator_declarator6618 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _block_in_operator_body6628 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _constructor_declarator_in_constructor_declaration6640 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _constructor_body_in_constructor_declaration6644 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_constructor_declarator6654 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_constructor_declarator6658 = new BitSet(new ulong[]{0x5E00010UL,0x610C0002UL,0x60DFFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _formal_parameter_list_in_constructor_declarator6662 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_constructor_declarator6667 = new BitSet(new ulong[]{0x2UL,0x10000000UL});
		public static readonly BitSet _constructor_initializer_in_constructor_declarator6671 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _92_in_constructor_initializer6682 = new BitSet(new ulong[]{0x0UL,0x180000UL});
		public static readonly BitSet _set_in_constructor_initializer6686 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_constructor_initializer6696 = new BitSet(new ulong[]{0x5E13FF0UL,0x20075FE4D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _argument_list_in_constructor_initializer6700 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_constructor_initializer6705 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _block_in_constructor_body6715 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _106_in_destructor_declaration6733 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_destructor_declaration6736 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_destructor_declaration6740 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_destructor_declaration6744 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _destructor_body_in_destructor_declaration6749 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _block_in_destructor_body6759 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _invocation_start_in_invocation_expression6771 = new BitSet(new ulong[]{0xC000UL,0x5000000UL});
		public static readonly BitSet _arguments_in_invocation_expression6793 = new BitSet(new ulong[]{0xC000UL,0x5000000UL});
		public static readonly BitSet _invocation_part_in_invocation_expression6797 = new BitSet(new ulong[]{0xC000UL,0x5000000UL});
		public static readonly BitSet _invocation_part_in_invocation_expression6808 = new BitSet(new ulong[]{0xC000UL,0x5000000UL});
		public static readonly BitSet _arguments_in_invocation_expression6814 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _predefined_type_in_invocation_start6824 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_invocation_start6841 = new BitSet(new ulong[]{0x0UL,0x2000000000UL});
		public static readonly BitSet _generic_argument_list_in_invocation_start6845 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _83_in_invocation_start6850 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _84_in_invocation_start6856 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_invocation_start6861 = new BitSet(new ulong[]{0x2UL,0x200000UL});
		public static readonly BitSet _85_in_invocation_start6866 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_invocation_start6870 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _typeof_expression_in_invocation_start6877 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _access_identifier_in_invocation_part6902 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _brackets_in_invocation_part6907 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _declaration_statement_in_statement6926 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _labeled_statement_in_statement6941 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _embedded_statement_in_statement6946 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _block_in_embedded_statement6958 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _selection_statement_in_embedded_statement6963 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _iteration_statement_in_embedded_statement6969 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _jump_statement_in_embedded_statement6975 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _try_statement_in_embedded_statement6982 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _checked_statement_in_embedded_statement6987 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _unchecked_statement_in_embedded_statement6992 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _lock_statement_in_embedded_statement6997 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _using_statement_in_embedded_statement7002 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _yield_statement_in_embedded_statement7008 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _unsafe_statement_in_embedded_statement7014 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _fixed_statement_in_embedded_statement7019 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_statement_in_embedded_statement7024 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _176_in_fixed_statement7036 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_fixed_statement7040 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _pointer_type_in_fixed_statement7044 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _fixed_pointer_declarators_in_fixed_statement7046 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_fixed_statement7050 = new BitSet(new ulong[]{0x4000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _embedded_statement_in_fixed_statement7054 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _fixed_pointer_declarator_in_fixed_pointer_declarators7064 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_fixed_pointer_declarators7069 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _fixed_pointer_declarator_in_fixed_pointer_declarators7073 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _identifier_in_fixed_pointer_declarator7085 = new BitSet(new ulong[]{0x0UL,0x4UL});
		public static readonly BitSet _66_in_fixed_pointer_declarator7089 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _fixed_pointer_initializer_in_fixed_pointer_declarator7093 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_fixed_pointer_initializer7105 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _73_in_unsafe_statement7114 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _block_in_unsafe_statement7118 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_labeled_statement7127 = new BitSet(new ulong[]{0x0UL,0x10000000UL});
		public static readonly BitSet _92_in_labeled_statement7131 = new BitSet(new ulong[]{0x4000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _statement_in_labeled_statement7135 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _local_variable_declaration_in_declaration_statement7146 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _local_constant_declaration_in_declaration_statement7152 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_declaration_statement7155 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _local_variable_type_in_local_variable_declaration7165 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _local_variable_declarators_in_local_variable_declaration7169 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _177_in_local_variable_type7185 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _178_in_local_variable_type7196 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _type_in_local_variable_type7201 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _local_variable_declarator_in_local_variable_declarators7211 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_local_variable_declarators7214 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _local_variable_declarator_in_local_variable_declarators7216 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _identifier_in_local_variable_declarator7228 = new BitSet(new ulong[]{0x2UL,0x4UL});
		public static readonly BitSet _66_in_local_variable_declarator7231 = new BitSet(new ulong[]{0x4000000001E13FF0UL,0x20075F85DC0012UL,0xE05FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _local_variable_initializer_in_local_variable_declarator7235 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_local_variable_initializer7248 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _array_initializer_in_local_variable_initializer7253 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _stackalloc_initializer_in_local_variable_initializer7259 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _179_in_stackalloc_initializer7268 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unmanaged_type_in_stackalloc_initializer7272 = new BitSet(new ulong[]{0x0UL,0x1000000UL});
		public static readonly BitSet _88_in_stackalloc_initializer7276 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_stackalloc_initializer7280 = new BitSet(new ulong[]{0x0UL,0x2000000UL});
		public static readonly BitSet _89_in_stackalloc_initializer7284 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _81_in_local_constant_declaration7294 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_local_constant_declaration7298 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _constant_declarators_in_local_constant_declaration7302 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_expression_statement7312 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_expression_statement7316 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_statement_expression7328 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _if_statement_in_selection_statement7339 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _switch_statement_in_selection_statement7344 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _IF_in_if_statement7356 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_if_statement7360 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _boolean_expression_in_if_statement7364 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_if_statement7368 = new BitSet(new ulong[]{0x4000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _embedded_statement_in_if_statement7372 = new BitSet(new ulong[]{0x2UL,0x0UL,0x10000000000000UL});
		public static readonly BitSet _else_statement_in_if_statement7381 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _180_in_else_statement7394 = new BitSet(new ulong[]{0x4000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _embedded_statement_in_else_statement7398 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _181_in_switch_statement7408 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_switch_statement7412 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_switch_statement7416 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_switch_statement7420 = new BitSet(new ulong[]{0x4000000000000000UL});
		public static readonly BitSet _switch_block_in_switch_statement7424 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _62_in_switch_block7434 = new BitSet(new ulong[]{0x8000000000000000UL,0x400000000UL,0x40000000000000UL});
		public static readonly BitSet _switch_sections_in_switch_block7438 = new BitSet(new ulong[]{0x8000000000000000UL});
		public static readonly BitSet _63_in_switch_block7443 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _switch_section_in_switch_sections7453 = new BitSet(new ulong[]{0x2UL,0x400000000UL,0x40000000000000UL});
		public static readonly BitSet _switch_labels_in_switch_section7464 = new BitSet(new ulong[]{0x4000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _statement_list_in_switch_section7468 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _switch_label_in_switch_labels7478 = new BitSet(new ulong[]{0x2UL,0x400000000UL,0x40000000000000UL});
		public static readonly BitSet _182_in_switch_label7490 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _constant_expression_in_switch_label7494 = new BitSet(new ulong[]{0x0UL,0x10000000UL});
		public static readonly BitSet _92_in_switch_label7498 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _98_in_switch_label7505 = new BitSet(new ulong[]{0x0UL,0x10000000UL});
		public static readonly BitSet _92_in_switch_label7509 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _while_statement_in_iteration_statement7520 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _do_statement_in_iteration_statement7525 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _for_statement_in_iteration_statement7530 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _foreach_statement_in_iteration_statement7535 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _183_in_while_statement7545 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_while_statement7549 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _boolean_expression_in_while_statement7553 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_while_statement7557 = new BitSet(new ulong[]{0x4000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _embedded_statement_in_while_statement7561 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _184_in_do_statement7571 = new BitSet(new ulong[]{0x4000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _embedded_statement_in_do_statement7575 = new BitSet(new ulong[]{0x0UL,0x0UL,0x80000000000000UL});
		public static readonly BitSet _183_in_do_statement7579 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_do_statement7583 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _boolean_expression_in_do_statement7587 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_do_statement7591 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_do_statement7595 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _185_in_for_statement7605 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_for_statement7609 = new BitSet(new ulong[]{0x3E13FF0UL,0x20075F84DC0012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _for_initializer_in_for_statement7613 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_for_statement7618 = new BitSet(new ulong[]{0x3E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _for_condition_in_for_statement7622 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_for_statement7627 = new BitSet(new ulong[]{0x5E13FF0UL,0x20075F84DC0012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _for_iterator_in_for_statement7631 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_for_statement7636 = new BitSet(new ulong[]{0x4000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _embedded_statement_in_for_statement7640 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _local_variable_declaration_in_for_initializer7656 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _statement_expression_list_in_for_initializer7661 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _boolean_expression_in_for_condition7673 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _statement_expression_list_in_for_iterator7683 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _statement_expression_in_statement_expression_list7693 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _91_in_statement_expression_list7696 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84DC0012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _statement_expression_in_statement_expression_list7698 = new BitSet(new ulong[]{0x2UL,0x8000000UL});
		public static readonly BitSet _186_in_foreach_statement7710 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_foreach_statement7714 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _local_variable_type_in_foreach_statement7718 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_foreach_statement7722 = new BitSet(new ulong[]{0x0UL,0x0UL,0x40UL});
		public static readonly BitSet _134_in_foreach_statement7726 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_foreach_statement7730 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_foreach_statement7734 = new BitSet(new ulong[]{0x4000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _embedded_statement_in_foreach_statement7738 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _break_statement_in_jump_statement7748 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _continue_statement_in_jump_statement7753 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _goto_statement_in_jump_statement7758 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _return_statement_in_jump_statement7763 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _throw_statement_in_jump_statement7768 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _187_in_break_statement7778 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_break_statement7782 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _188_in_continue_statement7792 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_continue_statement7796 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _189_in_goto_statement7806 = new BitSet(new ulong[]{0x1E00010UL,0x400000002UL,0x460400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_goto_statement7812 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _182_in_goto_statement7820 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _constant_expression_in_goto_statement7824 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _98_in_goto_statement7832 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_goto_statement7837 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _153_in_return_statement7847 = new BitSet(new ulong[]{0x3E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_return_statement7851 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_return_statement7856 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _190_in_throw_statement7866 = new BitSet(new ulong[]{0x3E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_throw_statement7870 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_throw_statement7875 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _191_in_try_statement7890 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _block_in_try_statement7894 = new BitSet(new ulong[]{0x0UL,0x0UL,0x0UL,0x3UL});
		public static readonly BitSet _catch_clauses_in_try_statement7900 = new BitSet(new ulong[]{0x2UL,0x0UL,0x0UL,0x3UL});
		public static readonly BitSet _finally_clause_in_try_statement7904 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _finally_clause_in_try_statement7916 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _192_in_catch_clauses7927 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _specific_catch_clauses_in_catch_clauses7932 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _general_catch_clause_in_catch_clauses7936 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _specific_catch_clause_in_specific_catch_clauses7947 = new BitSet(new ulong[]{0x2UL,0x0UL,0x0UL,0x1UL});
		public static readonly BitSet _192_in_specific_catch_clauses7952 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _specific_catch_clause_in_specific_catch_clauses7957 = new BitSet(new ulong[]{0x2UL,0x0UL,0x0UL,0x1UL});
		public static readonly BitSet _general_catch_clause_in_specific_catch_clauses7961 = new BitSet(new ulong[]{0x2UL,0x0UL,0x0UL,0x1UL});
		public static readonly BitSet _90_in_specific_catch_clause7973 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _class_type_in_specific_catch_clause7977 = new BitSet(new ulong[]{0x5E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_specific_catch_clause7981 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_specific_catch_clause7986 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _block_in_specific_catch_clause7990 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _block_in_general_catch_clause8000 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _193_in_finally_clause8010 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _block_in_finally_clause8014 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _96_in_checked_statement8024 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _block_in_checked_statement8028 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _97_in_unchecked_statement8038 = new BitSet(new ulong[]{0x4000000002000000UL,0x4000000UL});
		public static readonly BitSet _block_in_unchecked_statement8042 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _194_in_lock_statement8052 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_lock_statement8056 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_lock_statement8059 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_lock_statement8063 = new BitSet(new ulong[]{0x4000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _embedded_statement_in_lock_statement8067 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _USING_in_using_statement8077 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_using_statement8081 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84DC0012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _resource_acquisition_in_using_statement8086 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_using_statement8090 = new BitSet(new ulong[]{0x4000000003F53FF0UL,0x20075F84DE0212UL,0xFFA705FFF7DFFFB0UL,0x7FCUL});
		public static readonly BitSet _embedded_statement_in_using_statement8095 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _local_variable_declaration_in_resource_acquisition8111 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _expression_in_resource_acquisition8116 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _195_in_yield_statement8126 = new BitSet(new ulong[]{0x0UL,0x0UL,0x800000002000000UL});
		public static readonly BitSet _153_in_yield_statement8131 = new BitSet(new ulong[]{0x1E13FF0UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_yield_statement8135 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_yield_statement8139 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _187_in_yield_statement8154 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_yield_statement8158 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_predefined_type0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _IDENTIFIER_in_identifier8261 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _also_keyword_in_identifier8265 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_keyword0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_also_keyword0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _set_in_literal0 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _assignment_in_assignment_list10780 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_assignment_list10782 = new BitSet(new ulong[]{0x1E13FF2UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _attributes_in_field_declarations10795 = new BitSet(new ulong[]{0x1E00010UL,0x5FFF3UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _modifiers_in_field_declarations10800 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_field_declarations10805 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _field_declaration_in_field_declarations10809 = new BitSet(new ulong[]{0x1E00012UL,0x105FFF3UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _attributes_in_property_declaration_list10822 = new BitSet(new ulong[]{0x1E00010UL,0x5FFF3UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _modifiers_in_property_declaration_list10827 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_property_declaration_list10832 = new BitSet(new ulong[]{0x1E03FF0UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _property_declaration_in_property_declaration_list10836 = new BitSet(new ulong[]{0x1E00012UL,0x105FFF3UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _constant_declaration_in_constant_declarations10848 = new BitSet(new ulong[]{0x2UL,0x20000UL});
		public static readonly BitSet _literal_in_literals10858 = new BitSet(new ulong[]{0x1E03FF2UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _attributes_in_delegate_declaration_list10870 = new BitSet(new ulong[]{0x2000000000080000UL,0x80101FFF9UL,0x120008000000UL});
		public static readonly BitSet _modifiers_in_delegate_declaration_list10875 = new BitSet(new ulong[]{0x2000000000080000UL,0x80101FFF9UL,0x120008000000UL});
		public static readonly BitSet _delegate_declaration_in_delegate_declaration_list10880 = new BitSet(new ulong[]{0x2000000000080002UL,0x80101FFF9UL,0x120008000000UL});
		public static readonly BitSet _local_variable_declaration_in_local_variable_declaration_list10893 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_local_variable_declaration_list10895 = new BitSet(new ulong[]{0x1E00012UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _local_variable_initializer_in_local_variable_initializer_list10908 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_local_variable_initializer_list10910 = new BitSet(new ulong[]{0x4000000001E13FF2UL,0x20075F85DC0012UL,0xE05FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _expression_in_expression_list_test10923 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_expression_list_test10925 = new BitSet(new ulong[]{0x1E13FF2UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _unary_expression_in_unary_expression_list10938 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_unary_expression_list10940 = new BitSet(new ulong[]{0x1E13FF2UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _invocation_expression_in_invocation_expression_list10953 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_invocation_expression_list10955 = new BitSet(new ulong[]{0x1E00012UL,0x1000180002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _primary_expression_in_primary_expression_list10968 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_primary_expression_list10970 = new BitSet(new ulong[]{0x1E03FF2UL,0x1F84180012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _non_assignment_expression_in_non_assignment_expression_list10983 = new BitSet(new ulong[]{0x2000000UL});
		public static readonly BitSet _SEMI_in_non_assignment_expression_list10985 = new BitSet(new ulong[]{0x1E13FF2UL,0x20075F84D80012UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _modifiers_in_method_declarations10998 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _82_in_method_declarations11002 = new BitSet(new ulong[]{0x1E03FF0UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_method_declarations11006 = new BitSet(new ulong[]{0x1E03FF0UL,0x2UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _method_declaration_in_method_declarations11009 = new BitSet(new ulong[]{0x1E00012UL,0x5FFF3UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _67_in_synpred1_cs291 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_name_in_synpred2_cs565 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_synpred2_cs569 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_name_in_synpred3_cs584 = new BitSet(new ulong[]{0x4000000000000000UL});
		public static readonly BitSet _62_in_synpred3_cs588 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_name_in_synpred4_cs603 = new BitSet(new ulong[]{0x4000UL});
		public static readonly BitSet _DOT_in_synpred4_cs607 = new BitSet(new ulong[]{0x0UL,0x80000UL});
		public static readonly BitSet _83_in_synpred4_cs611 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _83_in_synpred5_cs733 = new BitSet(new ulong[]{0x0UL,0x1000000UL});
		public static readonly BitSet _brackets_in_synpred5_cs738 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _84_in_synpred6_cs758 = new BitSet(new ulong[]{0x0UL,0x1000000UL});
		public static readonly BitSet _brackets_in_synpred6_cs762 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _object_creation_expression_in_synpred7_cs798 = new BitSet(new ulong[]{0xC000UL,0x1000000UL});
		public static readonly BitSet _set_in_synpred7_cs802 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _delegate_creation_expression_in_synpred8_cs846 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_synpred9_cs973 = new BitSet(new ulong[]{0x0UL,0x2000000000UL});
		public static readonly BitSet _generic_argument_list_in_synpred9_cs978 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _90_in_synpred10_cs1265 = new BitSet(new ulong[]{0x1E00010UL,0x40002UL,0x605FFF5DFFFB0UL,0x7F8UL});
		public static readonly BitSet _type_in_synpred10_cs1269 = new BitSet(new ulong[]{0x4000000UL});
		public static readonly BitSet _RPAREN_in_synpred10_cs1273 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _array_creation_expression_in_synpred11_cs1514 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _arguments_in_synpred12_cs1596 = new BitSet(new ulong[]{0xC000UL,0x1000000UL});
		public static readonly BitSet _set_in_synpred12_cs1600 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _unbound_type_name_in_synpred13_cs2170 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _generic_dimension_specifier_in_synpred14_cs2230 = new BitSet(new ulong[]{0x4000UL});
		public static readonly BitSet _DOT_in_synpred14_cs2234 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_synpred15_cs2380 = new BitSet(new ulong[]{0x0UL,0x2000000000UL});
		public static readonly BitSet _generic_argument_list_in_synpred15_cs2384 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_synpred16_cs2433 = new BitSet(new ulong[]{0x0UL,0x2000000000UL});
		public static readonly BitSet _generic_argument_list_in_synpred16_cs2437 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _predefined_type_in_synpred17_cs2538 = new BitSet(new ulong[]{0x0UL,0x1000000UL});
		public static readonly BitSet _type_name_in_synpred17_cs2542 = new BitSet(new ulong[]{0x0UL,0x1000000UL});
		public static readonly BitSet _rank_specifiers_in_synpred17_cs2546 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _predefined_type_in_synpred18_cs2573 = new BitSet(new ulong[]{0x0UL,0xC000000000UL});
		public static readonly BitSet _type_name_in_synpred18_cs2577 = new BitSet(new ulong[]{0x0UL,0xC000000000UL});
		public static readonly BitSet _102_in_synpred18_cs2582 = new BitSet(new ulong[]{0x2UL,0x4000000000UL});
		public static readonly BitSet _103_in_synpred18_cs2587 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _unary_expression_in_synpred19_cs2787 = new BitSet(new ulong[]{0x20000UL,0xFF80000000004UL});
		public static readonly BitSet _assignment_operator_in_synpred19_cs2791 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _cast_expression_in_synpred20_cs2855 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _anonymous_function_signature_in_synpred21_cs3075 = new BitSet(new ulong[]{0x0UL,0x0UL,0x8UL});
		public static readonly BitSet _131_in_synpred21_cs3079 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _query_expression_in_synpred22_cs3090 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _132_in_synpred23_cs3551 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _91_in_synpred24_cs4107 = new BitSet(new ulong[]{0x1E00010UL,0x2UL,0x60400F5DFFFB0UL,0x408UL});
		public static readonly BitSet _identifier_in_synpred24_cs4111 = new BitSet(new ulong[]{0x0UL,0x4UL});
		public static readonly BitSet _66_in_synpred24_cs4115 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_name_in_synpred25_cs4689 = new BitSet(new ulong[]{0x4000000000000000UL});
		public static readonly BitSet _62_in_synpred25_cs4693 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_name_in_synpred26_cs5628 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_synpred26_cs5632 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_name_in_synpred27_cs5653 = new BitSet(new ulong[]{0x4000000000000000UL});
		public static readonly BitSet _62_in_synpred27_cs5657 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_name_in_synpred28_cs6131 = new BitSet(new ulong[]{0x0UL,0x4000000UL});
		public static readonly BitSet _90_in_synpred28_cs6135 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_name_in_synpred29_cs6150 = new BitSet(new ulong[]{0x4000000000000000UL});
		public static readonly BitSet _62_in_synpred29_cs6154 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _member_name_in_synpred30_cs6169 = new BitSet(new ulong[]{0x4000UL});
		public static readonly BitSet _DOT_in_synpred30_cs6173 = new BitSet(new ulong[]{0x0UL,0x80000UL});
		public static readonly BitSet _83_in_synpred30_cs6177 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _arguments_in_synpred31_cs6778 = new BitSet(new ulong[]{0xC000UL,0x1000000UL});
		public static readonly BitSet _set_in_synpred31_cs6782 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_synpred32_cs6831 = new BitSet(new ulong[]{0x0UL,0x2000000000UL});
		public static readonly BitSet _generic_argument_list_in_synpred32_cs6836 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _declaration_statement_in_synpred33_cs6921 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _identifier_in_synpred34_cs6932 = new BitSet(new ulong[]{0x0UL,0x10000000UL});
		public static readonly BitSet _92_in_synpred34_cs6936 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _177_in_synpred35_cs7180 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _178_in_synpred36_cs7191 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _180_in_synpred37_cs7376 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _local_variable_declaration_in_synpred38_cs7651 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _local_variable_declaration_in_synpred39_cs8106 = new BitSet(new ulong[]{0x2UL});

	}
	#endregion Follow sets
}
